/*
 * Decompiled with CFR 0.151.
 *
 * Could not load the following classes:
 *  com.nokia.mid.ui.DirectGraphics
 *  com.nokia.mid.ui.DirectUtils
 *  javax.microedition.io.Connector
 *  javax.microedition.io.HttpConnection
 *  javax.microedition.lcdui.Canvas
 *  javax.microedition.lcdui.Font
 *  javax.microedition.lcdui.Graphics
 *  javax.microedition.lcdui.Image
 *  javax.microedition.media.Manager
 *  javax.microedition.media.Player
 *  javax.microedition.media.control.VolumeControl
 *  javax.microedition.rms.RecordEnumeration
 *  javax.microedition.rms.RecordStore
 */
import com.nokia.mid.ui.DirectGraphics;
import com.nokia.mid.ui.DirectUtils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Random;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.media.Manager;
import javax.microedition.media.Player;
import javax.microedition.media.control.VolumeControl;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordStore;

public final class a
        extends Canvas
        implements Runnable {
    private Font var_javax_microedition_lcdui_Font_a = Font.getFont((int)0, (int)0, (int)8);
    private int var_int_a = this.var_javax_microedition_lcdui_Font_a.charWidth('\u56fd');
    private int var_int_b = this.var_javax_microedition_lcdui_Font_a.getHeight();
    private int var_int_c = 75;
    private String var_java_lang_String_a = "$Rev: 3289 $";
    private String[] var_java_lang_String_arr_a;
    private boolean var_boolean_a;
    private Graphics var_javax_microedition_lcdui_Graphics_a;
    private boolean var_boolean_b;
    private int var_int_d;
    private byte gameStateFlag;
    private byte var_byte_b;
    private byte var_byte_c;
    private DirectGraphics var_com_nokia_mid_ui_DirectGraphics_a;
    private int var_int_e;
    private Image var_javax_microedition_lcdui_Image_a;
    private boolean var_boolean_c;
    private String[] var_java_lang_String_arr_b;
    private int[] var_int_arr_a;
    private Image[][] gamePngImagesGroups;
    private static int[] var_int_arr_b;
    private int[][] var_int_arr_arr_a;
    private InputStream var_java_io_InputStream_a;
    private OutputStream var_java_io_OutputStream_a;
    private InputStream var_java_io_InputStream_b;
    private int var_int_f;
    private int pressedKeyCode;
    private String[] var_java_lang_String_arr_c;
    private int var_int_h;
    private int var_int_i;
    private int var_int_j;
    private byte[] var_byte_arr_a;
    private int var_int_k;
    private int var_int_l;
    private int var_int_m;
    private int var_int_n;
    private int var_int_o;
    private int var_int_p;
    private int var_int_q;
    private byte[] var_byte_arr_b;
    private byte[] var_byte_arr_c;
    private byte var_byte_d;
    private int var_int_r;
    private int var_int_s;
    private Image var_javax_microedition_lcdui_Image_b;
    private int var_int_t;
    private int var_int_u;
    private String var_java_lang_String_b;
    private int var_int_v;
    private boolean var_boolean_d;
    private byte var_byte_e;
    private int[] var_int_arr_c;
    private int var_int_w;
    private int var_int_x;
    private boolean var_boolean_e;
    private boolean var_boolean_f;
    private byte var_byte_f;
    private byte var_byte_g;
    private byte playerCurrentEquipItemId;
    private byte var_byte_i;
    private int var_int_y;
    private int var_int_z;
    private String var_java_lang_String_c;
    private String var_java_lang_String_d;
    private String[] var_java_lang_String_arr_d;
    private int var_int_A;
    private int var_int_B;
    private int var_int_C;
    private int var_int_D;
    private int var_int_E;
    private int var_int_F;
    private int var_int_G;
    private int var_int_H;
    private int var_int_I;
    private int playerHp;
    private int playerAttack;
    private int playerAmaor;
    private byte playerWeapon;
    private byte playerCloth;
    private int[][] var_int_arr_arr_b;
    private int[] var_int_arr_d;
    private int var_int_M;
    private byte var_byte_l;
    private int playerPixelX;
    private int playerPixelY;
    private int playerXOffset;
    private int playerYOffest;
    private byte var_byte_m;
    private int var_int_R;
    private int var_int_S;
    private Image var_javax_microedition_lcdui_Image_c;
    private int[] var_int_arr_e;
    private int[] var_int_arr_f;
    private boolean var_boolean_g;
    private boolean var_boolean_h;
    private boolean var_boolean_i;
    private byte var_byte_n;
    private byte var_byte_o;
    private String[] var_java_lang_String_arr_e;
    private int[] mapObjectPixelX;
    private int[] mapObjectPixelY;
    private int[] spriteWidthLookupTable;
    private int[] var_int_arr_j;
    private int[] var_int_arr_k;
    private Image[] actorSpriteImages;
    /**
     * 对象Id查找表
     */
    private int[] objectIdLookupTable;
    private int[] var_int_arr_m;
    private int levelActorCount;
    private boolean[] spritePassable;
    private boolean[] var_boolean_arr_b;
    /**
     * 对象类型查找表
     */
    private byte[] objectTypeLookupTable;
    private short[] npcTalkIndexLookupTable;
    private boolean[] var_boolean_arr_c;
    private byte[] var_byte_arr_e;
    private byte[] monsterSpecialEffectArray;
    private int[] var_int_arr_n;
    private int[][] var_int_arr_arr_c;
    private byte[] var_byte_arr_g;
    private byte[] var_byte_arr_h;
    private boolean[] var_boolean_arr_d;
    private int var_int_U;
    private boolean var_boolean_j;
    private int var_int_V;
    private int var_int_W;
    private byte[][] var_byte_arr_arr_a;
    private byte[][] var_byte_arr_arr_b;
    private int X;
    private Image var_javax_microedition_lcdui_Image_d;
    private int m_mapWidth;
    private int m_mapHeight;
    private int pixelWidth;
    private int pixelHeight;
    private byte[] passableArray;
    private byte[] tileOperateModeArray;
    private boolean[][] mapPassBitmap;
    private byte[][] var_byte_arr_arr_c;
    private byte[] var_byte_arr_k;
    private byte[][] var_byte_arr_arr_d;
    private byte var_byte_p;
    private boolean[] var_boolean_arr_e;
    private int ac;
    private int ad;
    private int ae;
    private int af;
    private int preferWidth;
    private int perferHeight;
    private int ai;
    private int aj;
    private int ak;
    private int al;
    private boolean var_boolean_k;
    private boolean var_boolean_l;
    private int level;
    private int an;
    private int ao;
    private int ap;
    private int aq;
    private int ar;
    private int upperX;
    private int downX;
    private int upperY;
    private int downY;
    private int aw;
    private int ax;
    private int ay;
    private int az;
    private int aA;
    private int aB;
    private int aC;
    private String[] var_java_lang_String_arr_f;
    private int aD;
    private byte[] var_byte_arr_l;
    private boolean[] var_boolean_arr_f;
    private int aE;
    private int aF;
    private int aG;
    private int aH;
    private short[] var_short_arr_b;
    private short[] var_short_arr_c;
    private short[] var_short_arr_d;
    private int aI;
    private String[] var_java_lang_String_arr_g;
    private String[] var_java_lang_String_arr_h;
    private byte[] var_byte_arr_m;
    private String[] var_java_lang_String_arr_i;
    private String[] var_java_lang_String_arr_j;
    private byte[] var_byte_arr_n;
    private int currentBussinessManId;
    private int aK;
    private byte[] var_byte_arr_o;
    private byte[] var_byte_arr_p;
    private int aL;
    private int aM;
    private String var_java_lang_String_e;
    private String[] var_java_lang_String_arr_k;
    private String[] equipItemDescribs;
    private byte[] var_byte_arr_q;
    private int yellowKeyCount;
    private int blueKeyCount;
    private int redKeyCount;
    private int aQ;
    /**
     * 背包物品数量
     */
    private int bagItemCount;
    private byte[] playerBagArray;
    private byte[] itemCurrentUseContArray;
    private int aS;
    private int[] equipPropertyLookupTable;
    private byte[] equipObjectIdLookupTable;
    private int aT;
    private int aU;
    private int aV;
    private int aW;
    private int aX;
    private int aY;
    private int aZ;
    private int ba;
    private boolean isJDYEnabled;
    private boolean var_boolean_n;
    private String[] var_java_lang_String_arr_m;
    private int[] monsterHpBaseArray;
    private int[] var_int_arr_q;
    private int[] var_int_arr_r;
    private int[] monsterMoneyLookupTable;
    private int[] monsterAttackArray;
    private int[] monsterDefArray;
    private int[] monsterHpArray;
    private int bb;
    private int bc;
    private int bd;
    private int be;
    private int bf;
    private int bg;
    private int[] var_int_arr_w;
    private byte[] var_byte_arr_u;
    private int bh;
    private String[] var_java_lang_String_arr_n;
    private byte[] var_byte_arr_v;
    private byte[] var_byte_arr_w;
    private String[] var_java_lang_String_arr_o;
    private int bi;
    private int bj;
    private boolean[] var_boolean_arr_g;
    private int bk;
    private int bl;
    private byte var_byte_q;
    private String var_java_lang_String_f;
    private int bm;
    private int bn;
    private int bo;
    private byte var_byte_r;
    private int bp;
    private int bq;
    private int br;
    private int bs;
    private int bt;
    private int bu;
    private int bv;
    private int bw;
    private int bx;
    private byte var_byte_s;
    private byte var_byte_t;
    private int by;
    private int bz;
    private int bA;
    private boolean var_boolean_o;
    private short[] var_short_arr_e;
    private byte[][] var_byte_arr_arr_e;
    private byte[] var_byte_arr_x;
    private boolean var_boolean_p;
    private boolean[] var_boolean_arr_h;
    private byte[] var_byte_arr_y;
    private int[] var_int_arr_x;
    private int[] var_int_arr_y;
    private int[] var_int_arr_z;
    private int[] var_int_arr_A;
    private int[] var_int_arr_B;
    private int[] var_int_arr_C;
    private int[] var_int_arr_D;
    private byte[] var_byte_arr_z;
    private byte[] var_byte_arr_A;
    private int bB;
    private int bC;
    private int bD;
    private int bE;
    private int bF;
    private int bG;
    private RecordStore var_javax_microedition_rms_RecordStore_a;
    private RecordEnumeration var_javax_microedition_rms_RecordEnumeration_a;
    private ByteArrayOutputStream var_java_io_ByteArrayOutputStream_a;
    private DataOutputStream var_java_io_DataOutputStream_a;
    private DataInputStream var_java_io_DataInputStream_a;
    private byte[] var_byte_arr_B;
    private byte[][] levelSpritesData;
    private int bH;
    private byte[] var_byte_arr_C;
    private int bI;
    private byte[] var_byte_arr_D;
    private short[] var_short_arr_f;
    private short[] var_short_arr_g;
    private short[] var_short_arr_h;
    private short[] var_short_arr_i;
    private byte var_byte_u;
    private byte var_byte_v;
    private byte[] var_byte_arr_E;
    private int[] var_int_arr_E;
    private short[] var_short_arr_j;
    private short[] var_short_arr_k;
    private byte[] var_byte_arr_F;
    private int bJ;
    private int bK;
    private boolean[] var_boolean_arr_i;
    private byte[] var_byte_arr_G;
    private byte[] var_byte_arr_H;
    private byte[] var_byte_arr_I;
    private byte[] var_byte_arr_J;
    private byte[] var_byte_arr_K;
    private byte[] var_byte_arr_L;
    private short[] var_short_arr_l;
    private short[] var_short_arr_m;
    private byte[] var_byte_arr_M;
    private byte[] var_byte_arr_N;
    private byte[] var_byte_arr_O;
    private byte var_byte_w;
    private int[] var_int_arr_F;
    private boolean[] var_boolean_arr_j;
    private boolean[] var_boolean_arr_k;
    private int bL;
    private boolean var_boolean_q;
    private boolean var_boolean_r;
    private int bM;
    private byte var_byte_x;
    private boolean var_boolean_s;
    private byte[] var_byte_arr_P;
    private int bN;
    private int bO;
    private int bP;
    private byte var_byte_y;
    private boolean var_boolean_t;
    private int bQ;
    private int bR;
    private int[] var_int_arr_G;
    private byte var_byte_z;
    private byte[] var_byte_arr_Q;
    private int bS;
    private byte[][] var_byte_arr_arr_g;
    private short[][] var_short_arr_arr_a;
    private short var_short_a;
    private short var_short_b;
    private short var_short_c;
    private short var_short_d;
    private short[] var_short_arr_n;
    private short[] var_short_arr_o;
    private int bT;
    private boolean var_boolean_u;
    private boolean var_boolean_v;
    private boolean var_boolean_w;
    private byte var_byte_A;
    private int[] var_int_arr_H;
    private int bU;
    private int bV;
    private boolean var_boolean_x;
    private byte var_byte_B;
    private boolean var_boolean_y;
    private boolean var_boolean_z;
    private byte[] var_byte_arr_R;
    private byte[] var_byte_arr_S;
    private boolean var_boolean_A;
    private boolean var_boolean_B;
    private int[] var_int_arr_I;
    private int[] var_int_arr_J;
    private int bW;
    private int bX;
    private int bY;
    private boolean var_boolean_C;
    private String[] var_java_lang_String_arr_p;
    private int bZ;
    private boolean var_boolean_D;
    private byte var_byte_C;
    private static Player var_javax_microedition_media_Player_a;
    private Random var_java_util_Random_a;
    private final int[] var_int_arr_K;
    private int ca;
    private final byte[] var_byte_arr_T;
    private int cb;
    private int cc;
    private int[] objectIdLookupTable;
    private boolean var_boolean_E;
    private final byte[] var_byte_arr_U;
    private byte var_byte_D;
    private int[][] var_int_arr_arr_d;
    private Image[] var_javax_microedition_lcdui_Image_arr_b;
    private String[] var_java_lang_String_arr_q;
    private String[] var_java_lang_String_arr_r;
    private String var_java_lang_String_g;
    private int cd;
    private byte[] var_byte_arr_V;
    private int ce;
    private Object var_java_lang_Object_a;
    private int cf;
    private boolean var_boolean_F;
    private boolean var_boolean_G;
    private String var_java_lang_String_h;
    private int cg;
    private long var_long_a;
    private long var_long_b;
    private int ch;
    private int ci;
    private HttpConnection var_javax_microedition_io_HttpConnection_a;
    private boolean var_boolean_H;
    private byte[] var_byte_arr_W;
    private int cj;
    private int ck;

    public a() {
        new StringBuffer().append("(内部版本").append(this.var_java_lang_String_a.substring(4, this.var_java_lang_String_a.length() - 1)).append(")");
        this.var_java_lang_String_arr_a = new String[]{"无法再下一层了，这是你达到的最底层", "无法再上一层了，这是你达到的最高层", "无法再下去了。", "无法再上去了。", "俺，当世神界第一斗者，孙!悟!空! 自从受封为齐天大圣，掌管蟠桃园以来，一直逍遥快活，无拘束……", "你拥有更强力的装备，因此将捡到的丢弃了。", "直到那一天，遇到了她，在筋斗云上的我，竟然第一次心潮起伏，有了晕机的感觉……", "神仙动了感情，往往会万劫不复，\n这一次，让我付出了五百年的时间去忘记她……\n五指山脚下的沙子，掠过我的脸庞。\n沙子，跟时间一样，同样随风流逝；同样掩埋过去；\n多少次伸手想抓住，却从指隙溜走……\n看夜空，半梦半醒间，往事历历上心头……"};
        this.var_int_e = 0;
        this.var_javax_microedition_lcdui_Image_a = null;
        this.var_java_lang_String_arr_b = new String[]{"sflogo", "mapbg", "map", "actor", "sptmap", "sptprop", "sptarm", "sptenemy1", "ui", "xtq", "menu", "intro", "face", "sptenemy2", "end", "load"};
        this.var_int_arr_a = new int[]{8, 1, 12, 4, 13, 23, 10, 20, 25, 6, 2, 2, 12, 20, 1, 2};
        this.gamePngImagesGroups = new Image[this.var_int_arr_a.length][];
        this.var_int_arr_arr_a = new int[][]{{0, 1, 2}, {3, 5}, {4, 5}};
        this.var_java_io_OutputStream_a = null;
        this.var_java_io_InputStream_b = null;
        this.var_java_lang_String_arr_c = new String[]{"新游戏", "继续游戏", "载入进度", "保存游戏", "设置", "帮助", "关于", "退出", "返回菜单", "回放", "停止回放", "商店", "十全大补包", "攻防神油", "开门天天乐", "天庭消费券", "印度神血油", "跳过教程"};
        this.var_int_q = 25;
        this.var_byte_arr_b = new byte[]{-1, 0, 1, 1, 1, 0, -1, -1};
        this.var_byte_arr_c = new byte[]{-1, -1, -1, 0, 1, 1, 1, 0};
        this.var_byte_d = 0;
        this.var_int_r = 0;
        this.var_int_s = 0;
        this.var_int_arr_c = new int[]{0xF8F8F8, 0xAAAAAA, 0x888888, 0x444444, 0x111111};
        int[] nArray = new int[]{0, 12, 24, 36, 47, 57, 67, 75, 83, 89, 94, 97, 100, 97, 94, 89, 83, 75, 67, 57, 47, 36, 24, 12, 0};
        this.playerCurrentEquipItemId = 0;
        this.var_java_lang_String_arr_d = new String[50];
        this.var_int_I = this.var_int_b + 4;
        this.playerHp = 498;
        this.playerAttack = 10;
        this.playerAmaor = 10;
        this.playerWeapon = 0;
        this.playerCloth = 0;
        this.var_int_arr_arr_b = new int[][]{{0, 1, 0, 2}, new int[0], new int[0], new int[0]};
        this.playerPixelX = 192;
        this.playerPixelY = 352;
        this.playerXOffset = 6;
        this.playerYOffest = 11;
        this.var_int_arr_e = new int[4];
        this.var_int_arr_f = new int[4];
        this.var_java_lang_String_arr_e = new String[]{"无", "木", "铁", "银", "金", "布", "皮", "锁", "金"};
        this.var_int_arr_arr_c = new int[][]{{0}, {0, 1, 0, 2}, {0, 1, 2}, {0, 1, 2, 1}, {0, 1, 2, 2, 1, 0}, {0, 1, 2, 3, 2, 1}, {0, 1, 2, 3, 4}, {3, 4, 5, 6}, {4, 3, 2, 1, 0}, {2, 1, 0}, {2, 3, 4}};
        this.var_byte_arr_g = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 4, 2, 3, 3, 3, 3, 3, 3, 2, 3, 2, 2, 2, 3, 2, 3, 3, 3, 2, 3, 5, 3, 3, 3, 3, 3, 3, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0};
        this.var_byte_arr_h = new byte[]{32, 32, 32, 32, 45, 32, 32, 32, 32, 104, 35, 45, 30, 32, 32, 30, 30, 24, 25, 21, 32, 25, 25, 27, 31, 27, 23, 23, 23, 32, 32, 32, 32, 27, 27, 27, 27, 22, 22, 16, 25, 15, 20, 28, 26, 23, 34, 35, 24, 33, 22, 22, 28, 36, 38, 29, 34, 29, 30, 31, 33, 26, 30, 36, 23, 38, 33, 42, 32, 78, 38, 36, 32, 39, 59, 36, 32, 29, 37, 27, 17, 32, 32, 32, 29, 27, 32, 36};
        this.var_boolean_arr_d = new boolean[]{true, false, false, false, false, true, true, true, true, false, true, false, false};
        this.var_int_V = 0;
        this.var_int_W = 270;
        this.var_byte_arr_arr_a = new byte[][]{{0, 0, 0, 33, 56}, {0, 33, 0, 33, 56}, {0, 66, 0, 33, 56}, {2, 0, 0, 18, 26}, {3, 0, 0, 18, 34}, {1, 0, 0, 55, 61}, {4, 0, 0, 14, 26}, {4, 14, 0, 14, 26}, {4, 28, 0, 24, 26}};
        this.var_byte_arr_arr_b = new byte[][]{{6, -1, -79, 0, 3, -26, -5, 0, 4, 11, 6, 0, 5, -25, -53, 0, 0, -16, -27, 0}, {7, -1, -80, 0, 3, -26, -5, 0, 4, 11, 6, 0, 5, -25, -54, 0, 2, -16, -26, 0}, {8, -1, -81, 0, 3, -26, -5, 0, 4, 11, 6, 0, 5, -25, -55, 0, 1, -16, -25, 0}};
        int[] nArray2 = new int[]{0, 0, 11, 1, 1, 11, 11, 11, 0, 0};
        int[] nArray3 = new int[]{0, 0, 0, 0, 1, 1, 1, 11, 11, 11};
        this.var_boolean_arr_e = new boolean[]{false, true, false, true, true, true, true, false, true, false, false, true, true, true, true, false, true, true, true, true, true, true, false, false, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, true, true, true, true, false, false, false, false, true, true, true, true, false, false, false, false, true, true, true, true, false, false, false, false, true, true, true, true, false, false, false, false, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false};
        this.level = 0;
        this.ap = 0;
        this.aq = 55;
        this.aw = this.var_int_b + 90;
        this.ax = 115;
        this.var_java_lang_String_arr_f = new String[]{"声音", "小地图"};
        this.aD = this.var_int_b + 8;
        this.var_byte_arr_l = new byte[4];
        this.var_boolean_arr_f = new boolean[4];
        this.aE = 0;
        this.aF = 0;
        this.aG = 80;
        this.aH = 32 + this.aD;
        this.var_short_arr_b = new short[10];
        this.var_short_arr_c = new short[10];
        this.var_short_arr_d = new short[10];
        this.aI = 0;
        this.var_java_lang_String_arr_g = new String[]{"", "", "有些门不能用钥匙打开，只有当你打败它的守卫后才会自动打开。", "你购买了礼物后再与天宫商人对话，他会告诉你一些重要的消息。", "", "我听说在天宫中有2把隐藏的红钥匙。", "在这个区域不多次提升攻击力，就不能打败“杨戬副手”。切记前人教训！", "太上老君就在25楼。以你现在的状态去攻击他简直就是自杀。 你应当在取得更高级别的道具后再去打败他。", "不找到所有的暗墙29楼的暗道是不会打开的", "如果你到27楼时状态为：生命1500、攻击80、防御98、拥有1把蓝钥匙、5把黄钥匙。那么祝贺你，你的前期是比较成功的。", "六丁六甲的攻击力太高了，你最好到能对他一击必杀时再与他战斗。", "别匆忙，放慢速度。", "如果你能用好4种移动宝物，你不用与强敌作战就能上楼。", "", "你需要用“玄明石”取出37楼仓库内的所有宝物。", "谜题：“在3点，拥有传送功能的密宝就会出现。”", "“巫师”会用魔法攻击路过的人，在2个“太上老君护卫”间通过会使你的生命减少一半。", "44楼，被藏在异空间，你只能用密宝才能到达。", "41楼事实上是左右对称的。", "像骰子上5的形状是一种封印魔法，你最好记住它在你与49楼假魔王战斗时有用", "", "你好，我是太白金星。你最好别见敌人就杀，先往上走，拿到武器和防具再做打算。"};
        this.var_java_lang_String_arr_h = new String[]{"感谢你救了我，这是1000金就送给你吧。", "试下火眼金睛吧，你能看到怪物的信息和战斗损失的血量，你可以在物品栏中使用它。", "", "", "很好，你居然找到了我，作为奖励我将给你一瓶千年月桂露，喝了它将按你的攻击力和防御力的综合增加的你生命点数，你越晚使用它效果越好。", "", "", "", "", "", "", "", "", "", "感谢你救了我，这是1000金就送给你吧。", "", "", "", "", "", "哈喽，送你1000金作为见面礼，记得经常来找我哦。", ""};
        this.var_byte_arr_m = new byte[]{2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1};
        this.var_java_lang_String_arr_i = new String[]{"大圣饶命，我可以提升3%攻击力和防御力，需要小的为你效劳吗？", "", "大圣爷，我这里有1把蓝钥匙，你给50金币吧。", "我有5把黄钥匙，一共50金币", "嘿嘿，我有很多把黄钥匙，1把1000金币", "我有1把红钥匙，只要800金币", "我有1把蓝钥匙，只要200金币", "我跟其他人不一样，你可以把多余的钥匙卖给我。100金币回收1把黄钥匙", "我有1把黄钥匙，1把蓝钥匙，一共是1000金币", "我有3把黄钥匙，只要200金币", "我有3把蓝钥匙，收你2000金币", "我可以恢复你2000点血，不过要1000金币", "我有个宝物，要收你4000金币，是个玄明石。"};
        this.var_java_lang_String_arr_j = new String[]{"", "", "天宫一共50层，每10层为一个区域。如果不打败该区域的头目就不能到更高的地方。", "在商店里你最好选择提升防御力，只有在攻击力低于敌人的防御力时才提升攻击力。", "", "你是否注意到5、9、14、16、18楼有的墙与众不同？", "如果你持有太公杖，面对天神力士和巨灵神时你的攻击力加倍。在没有太公杖的情况下你是无法打败巨灵神的。太公杖被藏在15楼以上的墙内。", "", "天宫一共有50层，但50楼并不能直接上去。", "存放乌金棍的房间的门坏了，你必须用金勺子破墙而入。", "天宫中藏有有个“幸运金币”拥有它在打败敌人后能够获得2倍的金钱。", "“紫金龙鳞甲”能防御“太上老君护卫”的夹击，但它被深藏在神秘的楼层中。", "如果要打败杨戬你需要“乌金棍”、“银缕锁甲”、“捆仙绳”或更高等级的宝物。"};
        this.var_byte_arr_n = new byte[]{2, 3, 3, 3, 6, 3, 3, 6, 3, 3, 3, 3, 3};
        this.aK = this.var_java_lang_String_arr_g.length + this.var_java_lang_String_arr_j.length;
        this.var_byte_arr_o = new byte[this.aK];
        this.var_byte_arr_p = new byte[this.aK];
        this.var_java_lang_String_arr_k = new String[]{"能看破敌人底细，显示敌人详细信息。在游戏中按快捷键5也可以查看伤害量。\n\\c00ff00[使用次数：无限]", "记录前尘往事。\n\\c00ff00[使用次数：无限]", "在楼梯边，可以瞬间上下层，留神晕机。\n\\c00ff00[使用次数：无限]", "熄灭\\cFFCC33三昧真火\\r的神器。\n\\c00ff00[使用次数：无限]", "挖洞开墙越狱的利器,挫是挫了点，但是真的很好用。\n\\c00ff00[使用次数：1次]", "可以震开当前层所有的墙\n\\c00ff00[使用次数：1次]", "喝下后，增加相当于当前\\c00FFFF攻击力\\cFFFFFF加\\c00FFFF防御力\\cFFFFFF值740%的\\cFFCC00血量\n[月宫出品，手工酿制，不含三聚氰胺，冷藏效果更佳，使用次数：1次]", "瞬移到以中心为对称点的位置上。\n\\c00ff00[使用次数：3次]", "瞬移上行一层\n\\c00ff00[使用次数：1次]", "瞬移下行一层\n\\c00ff00[使用次数：1次]", "当年姜子牙受天命封神，他的钓鱼竹竿被原始天尊附上了神力，可以役使天神力士供他差遣，此杖又名“打神鞭”，对天神力士（包括巨灵神）威力加倍。\n\\cFFCC00[放在道具栏中有效]", "对某些自恋的神仙伤害加倍。\n\\cFFCC00[放在道具栏中有效]", "打怪得到的金钱加倍。\n\\cFFCC00[放在道具栏中有效]", "可以开启黄门。", "可以开启红门。", "可以开启蓝门。", "加攻击。", "加防御。", "加血。", "加血。", "开启当前层所有黄门", "如来开“慈悲为怀”巡回佛经演唱会的时候，伴奏罗汉用的乐器，道行浅的敌人，会被其梵天佛音瞬间化为灰飞\n\\cFFCC00使用：杀死上下左右的敌人，对BOSS不起作用。"};
        this.equipItemDescribs = new String[]{"", "\\cdddddd一根相当长的木制长棍,新手必备.有了它杀人越货不慌不愁.\n\\c00ff00装备: 攻击+10.\n\\cFFCC00\"看上去似乎会断掉。\".", "\\cdddddd乌黑油亮，显然经历过多人之手。\n\\c00ff00装备: 攻击+30.\n\\cFFCC00\"很粗很结实！\".", "\\cdddddd银棍，恩，有这个名字就足够了。\n\\c00ff00装备: 攻击+70.\n\\cFFCC00\"只是根银棍\".", "\\cdddddd因乘天地之灵气，集日月之精华乃“万木之灵，灵木之尊”。\n\\c00ff00装备: 攻击+120.\n\\cFFCC00\"木之精华，削铁断金\".", "\\cdddddd您的需要，它知道；您的需求，它满足。它好，你也好，龙王后宫，镇宫之宝！\n\\c00ff00装备: 攻击+220.\n\\cFFCC00\"不要迷恋它，它只是一根传说。\".", "", "\\cdddddd没有太多的装饰，一件非常朴素、轻便的布衣.\n\\c00ff00装备: 防御+10.\n\\cFFCC00\"看上去有不少人用过了。\".", "\\cdddddd保暖御寒，腰不酸，腿不疼，走路也有劲了。\n\\c00ff00装备: 防御+30.\n\\cFFCC00\"豹纹，性感又野性，今年天宫最流行的皮草款式\".", "\\cdddddd如果没有上面的那行字，它也算是个杰作。\n\\c00ff00装备: 防御+70.\n\\cFFCC00\"上面写着'办四级神仙证书，回收二手莲花宝座'\".", "\\cdddddd华丽的装饰，就是有点旧。\n\\c00ff00装备: 防御+120.\n\\cFFCC00\"别人穿过的极品。\".", "\\cdddddd东海龙鳞编织而成，限量版，天上天下，只此一款。\n\\c00ff00装备: 防御+220.\n\\cFFCC00\"更轻薄，更透气，更多防护，更多安心\"."};
        this.var_byte_arr_q = new byte[]{-1, -1, -1, -1, 1, 1, 1, 3, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
        this.yellowKeyCount = 0;
        this.blueKeyCount = 0;
        this.redKeyCount = 0;
        this.aQ = 0;
        this.playerBagArray = new byte[32];
        this.itemCurrentUseContArray = new byte[32];
        int[] nArray4 = new int[]{0, 1, 2, 4, 8, 16, 32};
        this.equipPropertyLookupTable = new int[]{0, 10, 30, 70, 120, 220, 0, 10, 30, 70, 120, 220};
        this.equipObjectIdLookupTable = new byte[]{0, 33, 34, 35, 79, 36, 0, 37, 38, 39, 80, 40};
        this.var_java_lang_String_arr_m = new String[]{"孙悟空", "黄门", "红门", "蓝门", "封印门", "门卫", "隐形路径", "上楼梯", "下楼梯", "炼丹炉", "云雾", "能挖的墙", "隐形墙", "火眼金睛", "生死簿", "筋斗云", "芭蕉扇", "金勺子", "玄明石", "千年月桂露", "相形变位", "上行符", "下行符", "太公杖", "捆仙绳", "幸运币", "黄钥匙", "红钥匙", "蓝钥匙", "威力丹", "金刚丹", "回春丸", "长寿丹", "桃木棒", "玄铁棒", "真银棒", "金箍棒", "道袍", "铁甲", "锁子甲", "紫金龙鳞甲", "天宫小犬", "天宫大犬", "伴炉童子", "护庭小神", "守园仙婢", "护庭校尉", "巡天卫士", "巡天卫士", "巨力士", "执火道人", "奎木狼", "执瓶仙侍", "金刚力士", "护持迦蓝", "侍案仙女", "护庭神将", "赤力韦驮", "护丹老道", "伏魔韦驮", "兜率宫星君", "无量护法", "兜率宫老仙", "二郎执旗将", "杀破狼", "二郎骁骑将", "尊天韦驮", "啸天犬", "太上老君", "杨戬", "玉皇大帝", "玉皇大帝", "牛魔王", "天蓬元帅", "巨灵神", "哪吒", "路点", "太白金星", "天宫商人", "乌金棍", "银缕锁甲", "封印门", "传怪点", "剧情点", "嫦娥", "黄金钥匙", "日月无极钹", "菩提老祖"};
        this.monsterHpBaseArray = new int[]{35, 45, 35, 50, 60, 55, 100, 50, 260, 60, 130, 100, 320, 20, 320, 100, 210, 220, 160, 200, 230, 220, 200, 360, 180, 180, 1200, 4500, 1500, 8000, 800, 5000, 120, 444, 100};
        this.var_int_arr_q = new int[]{18, 20, 38, 42, 32, 52, 180, 48, 85, 100, 60, 95, 120, 100, 140, 680, 200, 180, 230, 380, 450, 370, 390, 310, 430, 460, 180, 560, 600, 5000, 500, 1580, 150, 199, 65};
        this.var_int_arr_r = new int[]{1, 2, 3, 6, 8, 12, 110, 22, 5, 8, 3, 30, 15, 68, 20, 50, 65, 30, 105, 130, 100, 110, 90, 20, 210, 360, 20, 310, 250, 1000, 100, 190, 50, 66, 15};
        this.monsterMoneyLookupTable = new int[]{1, 2, 3, 6, 5, 8, 100, 12, 18, 12, 8, 22, 30, 28, 30, 55, 45, 35, 65, 90, 100, 80, 50, 40, 120, 200, 100, 1000, 800, 500, 500, 500, 100, 144, 30};
        this.var_java_lang_String_arr_n = new String[]{"CES_84_6_11 MOV_0_5_11 TAK_8_9 CES_70_5_8 TAK_10_10 ROS_4_1 TAK_11_17 ROS_4_2 TAK_18_19 MOV_0_5_10 TAK_20_21 DES_70_5_8 LAY_2 ROS_1_4_7 ROS_2_0 ROS_2_6 RES_0 GUT_1 ", "TAK_22_22 ROS_4_3 TAK_23_32 MOV_72_3_7_1_8 ", "TAK_33_36 MOV_72_1_8_1_10 DES_72_1_10 ", "TAK_37_37 MOV_0_6_5 TAK_38_39 TAK_41_41 DES_44_1_3 DES_44_2_3 DES_44_3_3 DES_46_2_4 DES_44_9_3 DES_44_10_3 DES_44_11_3 DES_46_10_4 CES_44_5_4 CES_46_6_4 CES_44_7_4 CES_44_5_5 CES_44_7_5 CES_44_5_6 CES_46_6_6 CES_44_7_6 SWD TAK_42_42 ", "CES_72_1_11 TAK_43_44 MOV_0_6_3 MOV_72_1_11_6_2 ROS_4_1 TAK_45_48 MOV_72_6_2_6_1 DES_72_6_1 ", "TAK_49_52 MOV_72_9_1_7_1 DES_72_7_1 ", "TAK_53_58 ", "TAK_60_60 MOV_72_3_2_8_4 TAK_61_61 CES_47_8_3 CES_47_8_5 TAK_62_63 DES_72_8_4 DES_47_8_3 DES_47_8_5 ADD_2_72_11_10 ", "ROS_4_1 CES_73_10_1 MOV_73_10_1_6_9 TAK_68_74 MOV_73_6_9_6_10 ", "SWD ", "CES_72_3_10 MOV_72_3_10_2_10 MOV_72_2_10_4_9 TAK_76_78 DES_72_4_9 ", "SWD ", "TAK_84_87 MOV_58_5_4_6_8 MOV_58_4_4_6_8 MOV_58_3_4_6_8 MOV_57_7_4_6_8 MOV_57_8_4_6_8 MOV_57_9_4_6_8 MOV_56_4_2_6_8 MOV_56_3_2_6_8 MOV_56_2_2_6_8 MOV_59_8_2_6_8 MOV_59_9_2_6_8 MOV_59_10_2_6_8 TAK_88_90 MOV_73_6_2_6_8 ", "CES_6_10_2 CES_60_10_2 ", "ROS_4_1 TAK_92_97 DES_73_6_8 TAK_98_100 DES_70_6_7 ", "ROS_4_1 CES_61_5_2 CES_61_6_2 CES_61_7_2 CES_61_5_3 CES_70_6_3 CES_61_7_3 CES_61_5_4 CES_61_6_4 CES_61_7_4 TAK_118_121 ", "TAK_123_126 GUT_37 ", "TAK_68_74 ", "DES_1_4_4 CES_20_4_4 ", "CES_84_7_7 MOV_84_7_7_6_8 TAK_0_1 MOV_84_6_8_1_8 TAK_2_2 MOV_0_2_8 TAK_3_3 MOV_84_1_8_1_1 TAK_4_4 MOV_0_1_2 TAK_5_5 MOV_84_1_1_10_1 MOV_0_6_1 DES_84_10_1 TAK_6_7 MOV_0_11_1 MOV_0_1_11 ", "TAK_40_40 ", "TAK_59_59 ", "TAK_75_75 ", "TAK_84_87 GUT_12 ", "TAK_101_105 ", "CES_22_6_6 ", "TAK_129_132 DES_84_11_4 GIN_1_1000 ", "TAK_113_117 TAK_133_135 DES_84_6_11 GIN_0_13 ", "TAK_136_143 DES_84_1_11 TAK_144_144 GIN_0_19 ", "TAK_145_146 DES_84_9_8 GIN_1_1000 ", "MOV_84_6_3_4_3 MOV_84_4_3_8_3 MOV_84_8_3_6_3 TAK_107_107 ", "TAK_108_108 DES_10_6_6 MOV_0_6_5 TAK_109_112 TAK_147_148 DES_84_6_3 TAK_149_149 ", "TAK_79_79 ", "TAK_155_160 DES_72_11_10 ", "TAK_150_154 ", "TAK_161_161 ", "TAK_162_162 ", "GLV_1 ", "CES_6_4_1 CES_61_4_1 ", "", "TAK_255_259 TAK_165_165 SEE_3_10_166_166_1 ", "TAK_167_167 SEE_4_10_168_168_0 ROS_4_1 SEE_2_8_169_169_0 SEE_2_8_170_170_1 ", "TAK_171_171 SEE_7_10_172_172_0 SEE_7_10_173_173_1 ", "TAK_174_174 SEE_7_9_175_175_0 TAK_176_176 SEE_8_8_177_178_0 ", "TAK_179_180 ROS_4_3 SEE_8_6_181_182_0 ROS_4_1 SEE_10_4_183_183_0 ", "ROS_4_1 SEE_8_3_184_184_0 ROS_4_0 SEE_6_7_185_185_0 ", "SEE_4_4_186_186_0 ROS_4_1 SEE_6_2_187_187_1 ", "ROS_4_0 SEE_6_2_188_188_0 SEE_4_4_189_189_1 ", "TAK_190_190 ROS_4_1 SEE_2_2_191_192_0 ROS_4_0 SEE_2_6_193_196_0 SEE_2_6_197_198_1 ", "ROS_4_3 SEE_1_11_199_200_0 ", "ROS_4_2 SEE_6_11_201_202_0 ROS_4_3 SEE_3_8_203_204_0 CES_6_3_10 SEE_3_8_205_205_1 ", "TAK_206_209 ", "TAK_210_211 SEE_11_11_212_212_0 SEE_11_7_213_214_0 TAK_215_216 ", "TAK_217_218 ROS_5_510 ROS_6_510 CES_36_11_8 SEE_11_8_219_221_0 CES_40_11_9 SEE_11_9_222_222_0 SEE_8_9_224_225_0 SEE_10_9_223_223_0 DES_11_10_9 ", "TAK_224_224 SEE_6_2_225_225_0 ", "TAK_226_227 ROS_5_510 ROS_6_510 CES_36_5_1 CES_40_7_1 TAK_228_228 ", "TAK_229_231 MOV_0_6_7 TAK_232_232 DES_51_2_8 DES_51_1_8 DES_51_2_9 DES_51_1_9 CES_51_6_6 CES_51_5_7 CES_51_6_8 CES_51_7_7 GUT_57 ", "MOV_51_6_6_6_7 ROS_4_3 MOV_51_5_7_6_7 ROS_4_0 MOV_51_6_8_6_7 ROS_4_2 MOV_51_7_7_6_7 ROS_4_1 TAK_233_235 MOV_74_7_4_6_7 GUT_61 ", "", "", "", "TAK_236_238 MOV_75_5_4_6_7 TAK_239_239 GUT_62 ", "CES_69_5_5 CES_47_5_6 CES_47_5_7 CES_47_5_8 CES_56_7_6 CES_56_7_7 CES_56_7_8 TAK_240_245 GUT_63 ", "CES_77_6_6 TAK_246_250 DES_71_6_3 DES_77_6_6 DES_69_5_5 DES_-66_0 DES_-56_0 DES_-49_0 DES_-47_0 DES_-69_0 ", "TAK_253_254 ", "TAK_127_128 END_0 ", "TAK_261_263 SMS_0 ", "TAK_264_268 "};
        this.var_byte_arr_v = new byte[]{0, 84, 0, 84, 0, 84, 0, 0, 84, 0, 70, 0, 70, 0, 70, 0, 70, 0, 84, 0, 0, 70, 72, 0, 72, 0, 72, 0, 72, 0, 72, 0, 72, 0, 72, 0, 72, 75, 0, 75, 75, 75, 0, 72, 0, 72, 0, 72, 0, 72, 0, 72, 0, 74, 0, 74, 0, 74, 0, 74, 72, 72, 47, 72, 0, 72, 72, 0, 73, 0, 73, 0, 73, 0, 73, 73, 72, 0, 72, 72, 0, 72, 72, 0, 73, 0, 73, 0, 73, 0, 73, 0, 70, 73, 70, 73, 70, 73, 73, 0, 70, 69, 0, 69, 0, 69, 84, 0, 0, 84, 0, 84, 0, 84, 0, 84, 0, 84, 70, 0, 70, 0, 70, 72, 0, 72, 0, 0, -1, 0, 84, 0, 84, 84, 0, 84, 0, 84, 0, 84, 0, 84, 0, 84, 0, 84, 0, 0, 0, 0, 69, 69, 0, 69, 0, 0, 72, 0, 72, 0, 72, 0, 0, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 0, 87, 87, 87, 87, 87, 87, 0, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 71, 71, 0, 71, 71, 74, 71, 75, 0, 71, 71, 69, 47, 69, 56, 69, 47, 77, 77, 77, 71, 0, 56, 71, 0, 0, 87, 0, 87, 0, 87, 0, 87, 0, 0, 87, 87, 87, 87, 87};
        this.var_byte_arr_w = new byte[]{7, 5, -1, 3, -1, 5, -1, 1, 10, 0, -1, -1, -1, -1, -1, -1, -1, 1, 9, 7, 8, -1, -1, 5, 11, 2, 6, -1, -1, -1, -1, 3, 11, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, -1, 11, -1, 5, 0, 5, 9, 2, 10, 3, -1, -1, 11, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, 10, -1, -1, 9, 0, 1, -1, -1, -1, -1, -1, -1, 3, 11, -1, 0, 3, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, 5, -1, 1, 3, -1, 8, 9, 8, 9, -1, -1, -1, 8, 4, 5, 6, 10, 8, -1, -1, 5, 9, 1, -1, 0, 3, 7, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, -1, 0, -1, -1, -1, -1, -1, -1, 7, -1, 7, -1, 7, 2, 2, -1, 2, -1, -1, -1, 7, -1, -1, -1, -1, -1, -1, -1, -1, 9, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
        this.var_java_lang_String_arr_o = new String[]{"姑娘，您……", "哎呀，姑奶奶我好不容易怀揣2个仙桃夹带出来，居然被发现了~！快闪！！", "……，跑都跑的这么优雅。", "哎呀，跑这么快……", "修逗妈待~！……", "死猴子，穷追猛打，追的人家小心肝噗嗵噗嗵地……", "啊~~~姑娘哟~~姑~~~娘~~！！", "死开死开~！！好狗不挡路。", "居然追到这里了，算了吧，认了吧。\n\\cFFCC00两个桃子滚落地上", "哎~~~~~~~", "我咤~~~~！天庭圣地，禁止喧哗。", "我~~~~", "我什么我~？？整天身居仙位，游手好闲……", "你~~~~~~~~~", "你什么你~？？看嫦娥衣杉不整，是不是你非礼~？？是不是你是不是你是不是你！？", "她~~~~~~~~~~", "她什么她~？？哦~！还滚出来2个仙桃！！假公济私是吧~！！猴子偷桃是吧！！", "俺没~！……", "……", "你……叫嫦娥？这个名字，俺，记。住。了……", "没错，桃子就是俺偷的！！俺认罚！", "将这只孽畜剥下铠甲打下天牢！", "贤弟，快醒醒……", "哎呦……老牛，醒来见你那张脸，真提神！！", "我宁愿看着你，睡得如此沉静，胜过你醒时决裂般无情~~", "靠，发春呐，把~手~拿~开~~！", "哟~~挺横得嘿~牛哥学得一手好摄影……刚才……", "……大哥久违了，多日不见，受小弟一拜！！", "话说你一直在梦中叫着一个人的名字，她一定偷了你很多桃子……", "没错，她是偷了我的东西，但是不是桃子，我很想再见她……", "恩恩，现在大哥带你从密道出去……", "……这你都能挖开~！！", "哥在魔界有个绰号，叫“溜得滑”，没有什么囚牢能困住哥……", "大哥！！能不能分我件东西遮遮羞……", "有，我这有把刚挖地道的破勺，你拿去挡住先！", "靠……算了，总比没有好。……", "没办法，你就将就一下啦。\\cFFCC00有件道童的旧袍子在9楼，你仔细找找吧，\\cF8F8F8我先撤了……", "妖猴，你可认得本少爷！！", "咝~~我看你骨骼清奇三头六臂，猜得不错的话，阁下一定是畸形儿！", "啊~！大哥果然高手！这都被你看穿了！不能留你活口了！", "哎呀呀~~我回去告诉我爹去！", "来人！把妖猴拿下！", "哦~~~喳~！李小猴踢馆！！", "贤弟，慢着！", "溜得滑？", "我偷偷告诉你哦，有个银棍在17层，你找到它以后就能厉害很多？", "了解！", "红了红脸", "尽快去吧，我闪先……", "贤弟，这只啸天犬在这里挡道太危险了，跟哥哥绕密道吧。", "一只看门的宠物，能凶到哪里？", "不是，自从调到天庭守路，已经很多天没有吃荤腥了……", "了解，绕道，走~！", "我乃托塔天王麾下先锋官，巨玲神是也！你欺我孩儿……", "欺你孩儿~？", "其实……哪吒是奴家跟托塔天王的私生子……", "你是女将！？", "其实，看我像芙蓉姐姐一样的好身段，你就应该了解……", "……咝~~托塔天王口味这么偏……", "啊~~~天王，巨玲儿不能陪伴你了……", "看来你已经打通暗墙了，看哥的。", "噢，通完收工，走！！……", "我们是天庭市容管理队！！啊哈~乱堆渣土，违规施工终于被抓个现行！", "哎呀~！兄弟，一定要来2层天牢救我呀！", "", "", "", "", "你就是孙悟空！？", "俺就是。", "我常去广寒宫看她，她这几天常常提到你……我从来不知道什么叫做嫉妒，但是这次，我想要你的命。", "哼，你哪位？", "我乃天蓬元帅，朱刚鬣！！掌管天河……", "猪肛裂？？好，满足你这个愿望……", "哎……我还没报完呢……", "菊花残~~~满地伤……", "你跟杨戬一战，天庭都开了盘口，赔率是1:5，哥把私房钱都押到你头上了，表辜负哥哥哟~", "……真想背后给你一闷棍……", "天庭禁止乱堆渣土，哥哥把渣土运到“天庭城管办事处”去，就不算乱堆了，捏嘿嘿~~", "\\cFFCC0023层乃是29层的地基所在，找出暗藏的墙，就可以让29层的墙松动，哥哥就可以挖穿它。", "……你个假仗义！", "兄弟，赶快去凑齐装备，打败杨戬，", "哥哥就发达了~嘿嘿~", "……", "上次趁本元帅自报大名的时候，突袭本帅，本帅不跟你计较，单挑还是群殴，你自己选。", "恩，是条汉子，俺就认真跟你打一次，单挑！", "单挑是吧，你一个单挑我们全部，弟兄们，一起上！", "你丫不地道！", "你的确是个英雄，难怪她一直念念不忘……", "过奖过奖，你的部下都躺下了，现在轮到你了……", "恩~~讨厌死了，来了来了……", "人家今天身体不方便，改天再来，先闪了", "天蓬，你数次战悟空不胜倒罢了，平时常常擅自离岗，去广寒宫把妞……死罪可免，活罪难饶。", "听说，下凡投胎，就会堕入轮回，就会忘记前尘往事……", "好，朕就成全你，下凡之前，有什么要求么？", "天天大吃大喝，倒头睡觉，生活安逸无边，心宽体胖……", "很好，你的心意，朕明白了，安心去吧", "哇！！投胎为猪？？！", "天蓬元帅变成了一只猪，被贬下了凡尘", "……真阴险……", "哼，哼，寡人在四十九层等你，哇哈哈哈哈~！！", "本来，战神情圣的名号是我的；嫦娥的心，迟早也会归属于我，但是你来了之后，一切都改变了……", "你喜欢她，这么多年，你为什么不去找她？", "因为我是战神情圣，是不能失败的……", "你太骄傲了……", "无论如何，斗神和战神这一战，是注定的……", " ", "哇，姑娘身陷三昧真火当中，要想办法开门灭火……", "姑娘顶住，俺老孙来救你！！", "不要不要过来！！", "姑娘你没事吧？", "死猴子，月宫阴冷，姑奶奶我想蒸蒸桑拿，治多年的关节炎都不行……", "……", "死猴子，上次桃子的事情……", "俺掌管蟠桃园，偷吃仙桃何止千百，多认2个，算什么……", "害你被革除了“齐天大圣”的上仙之位……", "俺老孙不稀罕天宫的位子，~贬下凡尘仍称王，嘿嘿", "……在天宫几千年，从来没有人肯为我放弃仙位……唉，可惜。", "哼哼，居然打到这里，实话告诉你，所有天神都对你不满，这次你被削去仙爵打入天牢，都是计划之中。", "那嫦娥呢，桃子呢？也在计划之中？你们料定俺会甘心顶罪？", "哇哈哈哈哈~！天网易逃，情丝难断，你有通天的本事，也难过这一关。", "为她顶罪，俺从不后悔，现在，是俺了断恩怨的时候了！！", "其实，朕不是打不过你，朕只不过私挪了国库，买了你的盘口……", "你终于打到这里了。", "你居然在这里？", "哈哈哈哈，老夫一路保你，就是为了让你帮我扫清天庭，你的所做所为…", "俺最恨的就是被人欺骗！我……（悟空久久地陷入了回忆）", "天庭，天庭又怎样？女人骗我，兄弟骗我，如今俺老孙没有什么可以留恋的，回花果山罢了。", "孽畜，天庭威仪，岂能容你全身而退！！", "姑娘，你怎么会被关在这里！", "奴家暗中助你，触犯天条……", "玉帝老儿，待我打烂你的金冠！！姑娘你先离开，等俺回来！", "唉……你又何苦……", "这里有瓶火眼金睛牌眼影霜，去皱抗衰老，可以看清楚敌人的本质，金色质感贴合肤质，来自巴黎，你值得拥有。", "现在涂好了，看起来嗲不嗲~？", "恩……本来是只“猴妖”，现在是个“人妖”。", "嫦娥姑娘，想不到在这里遇到你。", "大圣，这是我亲手酿制的千年月桂露，喝下它，犹如脱胎换骨，体力大增。", "哦~？难道这是定情信物？", "而且，它还可以使人忘记红尘感情，我希望你能忘记我。", "啊~哈~给我一杯忘情水~换我一夜不流泪……姑娘，俺准备离开天庭，我希望你跟我一起走……", "违背天条，私奔，会被整个天界人肉搜索的……", "私奔？俺老孙不做那猥琐之事，待俺打上灵霄宝殿，让玉皇大帝亲口答应，整个天庭谁敢为难你！！", "大圣保重，此地奴家不宜久留，奴家不想连累你……", "姑娘！姑娘！", "大圣，前面凶险难测，奴家这里有点私房钱，送给你买点仙丹滋补身体吧……", "……姑娘对我一片真情，俺发誓要为你打下一片天", "跟俺走吧，回花果山去……", "表，姑奶奶我为了天宫护照，抛弃了前夫，我才表再跟你下凡，你……是个好人……(飘走)", "......女人如衣服，兄弟如手足，老牛~！俺来寻你！！", "宝扇宝扇告诉我，谁是这个世界上最型最猛的男人？", "（模仿扇子的声音）是你~是你~还是你", "真自恋……", "哇~！被你偷窥到了，本尊该杀你灭口，但是现在你还不配本尊出手。", "可恶，等俺老孙先找回俺那根如意棍子再来收拾你……\\cFFCC00先去2层天牢救老牛，让他替俺开暗墙绕过去", "老牛，俺救你来了~！", "平时让你帮忙，老是推三阻四，这次这么爽快，一定有问题~", "嘿嘿，35层有个三眼小白脸太恶心，替俺灭了他~~", "俺对小白脸木有兴趣……", "那就想办法帮俺绕过去~~", "嘿嘿，开自己的洞，让别人说去吧~~~", "?有根捆仙绳？似乎可以克制住那个三眼小白脸，恩，搞定他，捆绑他，拿他的芭蕉扇，哦也~", "有芭蕉扇可以灭火了，嫦娥姑娘，俺来啦~~！！对了，还有我的如意金箍棒。", "欢迎你来到天宫世界，我是你的师傅菩提老祖。", "在这里我不会教你七十二变，但是我会教你怎么游历天宫。", "为师知道你要大闹天宫，特意千里传音，提供远程视频支持，当然，如果你嫌为师罗嗦，也可以在游戏菜单中选择跳过教程。", "好了，现在请试着\\cFFCC00按方向键移动到这里。", "很好，你已经学会太空步了。", "在你面前有一道黄色的门，你无法过去。", "你可以看到这里有把黄钥匙，它可以开启这道门。", "现在\\cFFCC00移动到这里，再回来开门。", "等等！", "前面有只挡路的狗。你需要打败它才能走过去。", "现在，\\cFFCC00请试着移动到它的位置上，与它战斗吧。", "听到轰隆声了吧，因为你打败了\\cFFCC00守卫封印门的敌人。", "所以这里的\\cFFCC00封印门\\cF8F8F8就被打开了。", "在战斗中你可能会损失血量。", "这里有个\\cFFCC00小仙桃，可以回复你的血量。", "如果血量不足，你将无法挑战敌人。", "又到了学习时间。", "你的能力是可以提升的，包括攻击、防御、血量。", "这里有个蓝色仙丹，学名是“防御仙丹”，服下它，可以提升你的防御力，让你战斗更持久。", "记住，\\cFFCC00天庭层数越高，仙丹药效越大。", "现在，吃了它，扑过去做掉前面那条狗，你会发现损血少了。", "看到上面的蓝门了吗，它只能用蓝色的钥匙打开。", "它被藏在这里，\\cFFCC00先拿到它吧。", "你发现了一道红门。这种门很少见，必须用红钥匙才能打开。", "它被藏在这里，\\cFFCC00请先得到它，再回来开门。", "你找到了一把红钥匙，这种钥匙比较稀少。", "试着\\cFFCC00用它开启这里的红门。", "很好，这层已经接近尽头。", "你会发现这样的红色传送点，它可以让你向上一层楼。", "不过，别急着离开。", "你是不是已经发现这里有个道具了吗？", "这里有个红色仙丹，学名是“攻击仙丹”，服下它，可以提升你的攻击力，让你战斗更狂野。", "但是这里好象不通……", "别急！俗话说车到山前必有路，在天宫的很多层中会有隐藏的路，更多惊喜更多欢笑，就在隐藏路……", "现在，移动到这里，你就会发现它。", "要记住，\\cFFCC00很多层里都会有隐藏的东西，试着去探索吧。", "看到你上来的路了吗？", "蓝色的传送点可以让你向下一层楼。", "你可能无法击败这个敌人，绕道也是前进的办法。", "那么，如何判断一个敌人的强弱呢？", "游戏中你会获得这件宝物，它叫\\cFFCC00火眼金睛牌眼影膏。", "涂抹一点在眼皮上，你可以看破敌情，还可以去除眼角纹。", "我帮你开出了一条路，你可以去取它了。", "现在你可以参照使用说明来使用它了。", "除了按5/OK键查看敌人对你造成的伤害以外。", "你还可以按左软键打开物品栏。", "选择该物品，按确认键查看更详细的敌人信息。", "你站在这十字街头上，找不到来去的方向。", "不要慌张，试着查看下这里道具和敌人的分布形势。", "上去的传送点在这里。", "如果你无法马上击败这个守卫。", "就试着将地图上的仙丹和仙桃吃掉，然后你就可以战胜它了。", "记住，如果前方有一群敌人在向你挥手，千万别冲动。", "牢记\\cFFCC00“先吃仙丹后肉搏”\\cF8F8F8是减少损血的第一法则。", "哦嘿嘿~为师要继续享受渡假啦~。", "在这之前我会传授你五百年功力，再送你两件东西防身。", "这是一把武器，能让你提升很高的攻击。", "在游戏的\\cFFCC00每10层都有一把新武器。", "如果你能早点获得它，就能轻松应对敌人，走得更远。", "同样，这是一件防具，能提高你的防御。", "我现在帮你打开这道墙，在一般情况下，它是无法击碎的。", "对了，给你介绍一个天宫上的朋友。", "这是为师的老朋友，\\cFFCC00太白金星\\cF8F8F8，他会暗中帮助你的。", "恭喜，你已经毕业了，我再传授你五百年的功力。", "还给你准备了两件神器，把它们收下吧。", "要记住，往前你将面对的不是一个敌人，而是整个天宫。", "捏哈哈~今天风和日丽，朕心情很好~！", "呀~！哪里钻出一只果子狸！预防非典！左右与我拿下！", "什么破皇帝，五谷不分，六畜不辨……玉帝老儿，俺乃花果山第一届型秀冠军，美猴王孙悟空！！", "都给我上~！", "巨玲神，愣在那里做什么？", "陛下，人家是女孩子嘛，最怕毛茸茸地小动物了……", "少废话！想被砍头啊！", "陛下，三太子请战！", "玉帝老儿，俺老孙要做齐天大圣！！", "嗷~~它过来了它过来了，请你个头啊，赶紧顶上先~~", "护驾~！护驾~！", "谁~！是天庭第一型男~！！", "是你~！是你~！", "谁~！是天庭第一猛男~！！", "是你~！是你~！", "谁~！是天庭第一明星战神~！！", "你是电，你是光，你是唯一地神话，你主宰，我崇拜~没有更好的办法~~！", "陛下……呕……", "臣觉得吧……呕……", "还是不要让二郎神继续下去了，尽快平息这次事件，给孙悟空封个官算了！！", "呕~~朕也是这么想滴~~喔莱，就封孙悟空为齐天大圣，掌管蟠桃园！", "嘿嘿，俺老孙就领了~！多谢~！", "妖…妖怪，他的眼睛闪着红光……太可怕了", "居然退缩，你这没用的东西。", "噢~~~~~~满园仙桃成熟，煞是诱人！！", "让俺老孙四处逛逛~~", "悟空~悟空~！", "为什么有只酱油蛤蟆跟我千里传音？", "是师父我啊！", "师父？为什么化个蛤蟆妆？", "为师在印度，法术交流兼渡假，日光浴加顿顿咖喱饭，嘴巴上火。", "如来把孙悟空封印于五指山下，伴随着所有恩怨情仇，欲知后事如何，敬请期待《西游记二之大圣取经》", "爱徒啊，你一个人要继续挑战天宫，为师不放心，给你买了份保险。", "师傅够义气。", "（接过保单）受益人...“菩提老祖”", "我的徒儿啊，你已经陷入混沌世界。也就人们常说的精神分裂症。", "这是由于种种感情纠葛引发的，如果你想出来，就要战胜他们。", "不，是战胜自己。要让这天…再也遮不住你的眼。", "我要提醒你的是，这个世界里，所有的敌人都会比原来更强，当然你的能力也会提升更多。", "去吧……劫难在所难免。"};
        this.bj = this.var_java_lang_String_arr_n.length;
        this.var_boolean_arr_g = new boolean[this.bj];
        this.bo = 0;
        this.var_byte_arr_arr_e = new byte[][]{{29, 1, 3, 0, 29, 2, 3, 0, 29, 3, 3, 0, 26, 1, 4, 0, 26, 2, 4, 0, 26, 3, 4, 0, 30, 9, 3, 0, 30, 10, 3, 0, 30, 11, 3, 0, 32, 9, 4, 0, 32, 10, 4, 0, 32, 11, 4, 0}, {29, 4, 4, 0, 29, 4, 5, 0, 29, 5, 4, 0, 26, 7, 4, 0, 26, 8, 4, 0, 26, 8, 5, 0, 30, 4, 7, 0, 30, 4, 8, 0, 30, 5, 8, 0, 32, 8, 8, 0, 32, 7, 8, 0, 32, 8, 7, 0}, {27, 6, 5, 0, 27, 5, 6, 0, 27, 7, 6, 0, 27, 6, 7, 0}, {17, 6, 4, 0}, {16, 5, 5, 0}, {24, 6, 2, 0, 32, 5, 1, 0, 32, 6, 1, 0, 32, 7, 1, 0, 27, 6, 6, 0}, {32, 2, 3, 0, 32, 3, 3, 0, 32, 4, 3, 0, 26, 8, 3, 0, 26, 9, 3, 0, 26, 10, 3, 0, 29, 3, 5, 0, 29, 4, 5, 0, 29, 5, 5, 0, 30, 7, 5, 0, 30, 8, 5, 0, 30, 9, 5, 0}, {32, 4, 4, 0, 32, 5, 4, 0, 32, 6, 4, 0}};
        this.var_byte_arr_x = new byte[]{75, 74, 68, 67, 69, 71};
        this.var_boolean_p = false;
        this.var_javax_microedition_rms_RecordStore_a = null;
        this.var_javax_microedition_rms_RecordEnumeration_a = null;
        this.var_java_io_ByteArrayOutputStream_a = null;
        this.var_java_io_DataOutputStream_a = null;
        this.var_java_io_DataInputStream_a = null;
        this.var_byte_arr_B = null;
        this.levelSpritesData = new byte[56][];
        this.var_short_arr_f = new short[64];
        this.var_short_arr_g = new short[64];
        this.var_short_arr_h = new short[64];
        this.var_short_arr_i = new short[64];
        this.var_byte_arr_E = new byte[30];
        this.var_int_arr_E = new int[30];
        this.var_short_arr_j = new short[30];
        this.var_short_arr_k = new short[30];
        this.var_byte_arr_F = new byte[30];
        this.var_boolean_arr_i = new boolean[30];
        this.var_byte_arr_G = new byte[]{10, 6, -14, -26, -36, -38, -39, -41, -43};
        this.var_byte_arr_H = new byte[]{16, 4, -10, 0, 14, 12, 14, 11, 13};
        this.var_byte_arr_I = new byte[]{9, 22, 34, 41, 51, 52, 54, 55, 56};
        this.var_byte_arr_J = new byte[]{15, -2, -19, -1, 21, 17, 21, 19, 21};
        this.var_byte_arr_K = new byte[]{9, -1, -10, -22, -26, -27, -29, -30, -32};
        this.var_byte_arr_L = new byte[]{20, 1, -15, 0, 24, 20, 24, 20, 24};
        this.var_boolean_r = true;
        String[] stringArray = new String[]{"界面", "菜单", "地图", "背景", "人物", "组件", "表情", "效果", "脚本", "缓存", "楼层", "角色", "设定", "敌人", "引子", "结局", "载入进度"};
        this.bN = 0;
        this.bO = 0;
        this.bP = 0;
        int[] nArray5 = new int[]{0xEEEEEE, 0xCCCCCC, 0xAAAAAA, 0x888888, 0x666666, 0x444444, 0x222222, 0x111111};
        this.var_int_arr_G = new int[]{0xFF0000, 0xFF9000, 16776194, 1244928, 65478, 26367, 14156031};
        this.var_boolean_u = false;
        this.var_boolean_v = false;
        this.var_boolean_w = false;
        this.var_byte_A = 0;
        this.var_int_arr_H = new int[]{1, 30, 60, 80, 100};
        this.var_byte_arr_R = new byte[]{29, 31, 39, 15, 0, 31, 29, 10, 0, 0, 37, 31, 36, 0, 32, 29};
        this.var_byte_arr_S = new byte[]{1, 2, 0, 3, 4, 1, 2, 0};
        this.var_int_arr_I = new int[]{4, 2, 2, 2, 2, 2, 2};
        this.var_int_arr_J = new int[this.var_int_arr_I.length];
        this.var_java_lang_String_arr_p = new String[]{"logostart.mid", "logoquit.mid", "menu.mid", "game.mid"};
        this.bZ = 60;
        this.var_boolean_D = true;
        this.var_byte_C = (byte)-1;
        this.var_int_arr_K = new int[]{4202520, -1};
        int[] nArray6 = new int[]{2555941, 6436695};
        int[] nArray7 = new int[]{2555941, 10126750};
        int[] nArray8 = new int[]{12342908, 15039118};
        int[] nArray9 = new int[]{0x222222, 0xFFDF7D};
        this.var_byte_arr_T = new byte[]{87, 18, 9};
        this.objectIdLookupTable = new int[3];
        this.var_byte_arr_U = new byte[]{0, 5, 5, 5, 10, 4, 14, 7, 21, 4, 25, 3, 28, 3, 31, 4, 35, 3, 38, 4, 42, 4, 46, 4, 50, 4, 54, 3, 57, 3, 60, 4, 64, 2, 66, 2, 68, 4, 72, 4, 76, 5};
        this.var_int_arr_arr_d = new int[26][7];
        this.var_java_lang_String_arr_q = new String[]{"手机号", "密码", "试玩", "注册", "帮助", "注册帐号", "注册密码", "注册手机号必须为本机，验证成功后将获得200游戏币", "欢迎登陆雪鲤鱼平台", "确定", "取消", "退出", "联网中", "正在重试", "联网超时", "服务器没有响应", "登陆", "剩余点数", "查询记录", "充值", "个人信息", "帐号或密码输入有误", "请输入11位手机号", "请输入6-10位密码", "日期", "金额", "本月付费记录", "进入游戏", "请确认您填写的是当前手机号，否则会导致注册失败。资费2元，需要发送1条短信，2元/条，不含通信费。是否注册？", "已发送成功，请等待系统验证后才能登陆", "发送失败，请重试", "类型", "序列号", "密码", "金额", "元", "已提交充值信息，请在充值记录中查看充值结果。", "返回", "状态", "最近充值记录", "提交过程出现错误，请检查充值内容。", "：", "\n", "是否确定退出游戏？", "您尚未登陆，请输入您的手机号和密码联网付费", "序列号和密码填写有误", "短信充值", "已发送成功。", "服务器响应错误！", "使用本产品必须先登录，与雪鲤鱼其他产品中注册的手机号，密码，帐号中的游戏币通用。如果没有帐号可以注册，送游戏币。登录后付费信息更安全，避免掉存档。", "充值的游戏币在所有雪鲤鱼相关产品中通用。", "请输入11位手机号", "请输入6位以上密码", "是否马上注册？需要确认您填写的是当前手机号，否则会导致注册失败。资费2元，需要发送1条短信，2元/条，不含通讯费。", "注册失败！如果该手机号是您的真实号码。将会把您的密码改为当前注册填写的密码，该过程可能需要一段时间。", "已注册成功。待验证成功后就能用该号码充值！并购买游戏中的付费内容。如果再次注册还可以发送短信修改密码。", "您尚未验证，如果之前已发送短信验证，请稍候再登陆重试。", "客服电话：400 630 5518", "您的手机无法连接到服务器，不能进行游戏。是否重新尝试联网？"};
        this.var_java_lang_String_arr_r = new String[]{"http://218.202.228.126:8880/nolander/server.php", "http://chatsrv0.ttutt.cn/dntk/server.php"};
        this.cd = 2048;
        this.var_byte_arr_V = new byte[this.cd];
        this.var_boolean_F = false;
        this.var_javax_microedition_io_HttpConnection_a = null;
        this.var_boolean_H = true;
        this.setFullScreenMode(true);
        a a2 = this;
        if (a2.var_java_util_Random_a == null) {
            a2.var_java_util_Random_a = new Random();
            a2.var_java_util_Random_a.setSeed(System.currentTimeMillis());
        }
        this.var_boolean_a = true;
        this.gameStateFlag = 0;
        this.void_a();
    }

    protected final void paint(Graphics object) {
        int n;
        int n2;
        int n3;
        int n4;
        int n5;
        this.var_com_nokia_mid_ui_DirectGraphics_a = DirectUtils.getDirectGraphics((Graphics)object);
        this.var_javax_microedition_lcdui_Graphics_a = object;
        this.var_javax_microedition_lcdui_Graphics_a.setFont(this.var_javax_microedition_lcdui_Font_a);
        switch (this.gameStateFlag) {
            case 0: {
                if (this.var_int_e < 2) {
                    this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    this.var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, 320);
                    if (this.var_javax_microedition_lcdui_Image_a == null) break;
                    this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.var_javax_microedition_lcdui_Image_a, 240 - this.var_javax_microedition_lcdui_Image_a.getWidth() >> 1, 320 - this.var_javax_microedition_lcdui_Image_a.getHeight() >> 1, 0);
                    break;
                }
                this.H();
                break;
            }
            case 1: {
                object = this;
                n5 = 0;
                n5 = 320 - ((a)object).var_int_q - ((a)object).gamePngImagesGroups[10][0].getHeight();
                if (n5 > 0) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(6662375);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, n5);
                }
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[10][0], 0, n5, 0);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(3156024);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 320 - ((a)object).var_int_q, 240, ((a)object).var_int_q);
                super.b(((a)object).gamePngImagesGroups[10][1], 86, 320 - ((a)object).var_int_q + (((a)object).var_int_q - 17 >> 1), 0, 17 * ((a)object).var_byte_arr_a[((a)object).var_int_k], 60, 17, 17);
                n5 = 320 - ((a)object).var_int_q + (((a)object).var_int_q - 13 >> 1);
                super.void_a(((a)object).gamePngImagesGroups[8][14], 60 - ((a)object).var_int_U, n5, 1);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][14], 160 + ((a)object).var_int_U, n5, 0);
                this.var_javax_microedition_lcdui_Graphics_a.setClip(0, this.var_int_q, 240, 320 - (this.var_int_q >> 1));
                this.F();
                this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
                break;
            }
            case 2: {
                object = this;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(3156024);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, 320);
                ((a)object).bR = 148 * ((a)object).bN / 100;
                super.a(((a)object).gamePngImagesGroups[15][0], 108, 86, 0, 0, 24, ((a)object).bR);
                super.a(((a)object).gamePngImagesGroups[15][1], 108, 86 + ((a)object).bR, 0, ((a)object).bR, 24, 148 - ((a)object).bR);
                break;
            }
            case 11: {
                int n6;
                this.void_a(true);
                this.h(0, 20);
                this.a(this.ae, this.af + 20, true);
                this.D();
                this.void_d(0, 0);
                object = this;
                int n7 = 0;
                n4 = (((a)object).var_int_I << 1) + 12;
                int n8 = 320 - n4;
                if (((a)object).var_java_lang_String_c == null || ((a)object).var_boolean_f || ((a)object).var_byte_q == 4) {
                    super.e(0, ((a)object).var_int_W);
                    break;
                }
                Object var9_28 = null;
                super.b(0, n8, 80, n4);
                int n9 = n4;
                int n10 = 160;
                n3 = n8;
                n7 = 80;
                Object object2 = object;
                n7 = n3;
                for (n6 = 80; n6 < 214; n6 += 16) {
                    ((a)object2).var_javax_microedition_lcdui_Graphics_a.setClip(n6, n7, 16, 16);
                    ((a)object2).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object2).gamePngImagesGroups[8][0], n6 - 26, n7, 0);
                }
                ((a)object2).var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
                super.a(((a)object2).gamePngImagesGroups[8][0], 214, n7, 0, 0, 26, 16, 1);
                ((a)object2).var_javax_microedition_lcdui_Graphics_a.setColor(2699825);
                ((a)object2).var_javax_microedition_lcdui_Graphics_a.fillRect(80, n7 += 16, 149, n9 - 16);
                while (n7 < n3 + n9) {
                    ((a)object2).var_javax_microedition_lcdui_Graphics_a.setClip(229, n7, 11, 16);
                    ((a)object2).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object2).gamePngImagesGroups[8][0], 176, n7, 0);
                    n7 += 16;
                }
                ((a)object2).var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
                if (((a)object).var_byte_r > 0) {
                    Image image = ((a)object).actorSpriteImages[((a)object).var_byte_r];
                    if (((a)object).var_byte_r != 72) {
                        n4 = image.getHeight();
                        super.a(image, 0 + (80 - ((a)object).var_byte_arr_h[((a)object).var_byte_r] >> 1), 320 - n4, 0, 0, ((a)object).var_byte_arr_h[((a)object).var_byte_r], n4);
                    } else {
                        super.a(image, 24, 275, 0, 0, 32, 45);
                    }
                } else if (((a)object).var_byte_r == 0) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[3][1], 40 - (((a)object).gamePngImagesGroups[3][1].getWidth() >> 1), 320 - ((a)object).gamePngImagesGroups[3][1].getHeight(), 0);
                } else {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString("?", 40, n8 + (n4 - ((a)object).var_int_b >> 1), 17);
                }
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(10473684);
                super.a(((a)object).var_java_lang_String_c, 85, n8 + 12, 129, n4 - 12, false);
                if (((a)object).var_int_A > 0) {
                    super.a(((a)object).gamePngImagesGroups[8][15], 220, 320 - ((a)object).var_int_I - 10, 0, 0, 7, 9);
                }
                if (((a)object).var_int_B < ((a)object).var_int_C) {
                    super.a(((a)object).gamePngImagesGroups[8][15], 220, 320 - ((a)object).var_int_I + 1, 7, 0, 7, 9);
                }
                if ((((a)object).var_byte_q == 6 || ((a)object).var_byte_q == 1) && (n4 = ((a)object).var_byte_arr_w[((a)object).bi]) >= 0) {
                    if (((a)object).bp >= 0) {
                        n7 = ((a)object).mapObjectPixelX[((a)object).bp] + 16;
                        n8 = ((a)object).mapObjectPixelY[((a)object).bp] - 30;
                        if (((a)object).var_byte_r == 84) {
                            n8 -= 20;
                        }
                    } else {
                        n7 = ((a)object).playerPixelX + 16;
                        n8 = ((a)object).playerPixelY - 30;
                    }
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[12][n4], n7 + ((a)object).ae, n8 + ((a)object).af + 20, 0);
                }
                if (((a)object).var_byte_q != 6) break;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[2][11], ((a)object).ae + 5 + (((a)object).bk << 5), ((a)object).af + (((a)object).bl << 5) - 12 + ((a)object).var_int_U, 0);
                break;
            }
            case 21: {
                object = this;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, 320);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString("是否开启声音？", 120, 160, 17);
                super.m();
                break;
            }
            case 3: {
                this.void_a(true);
                this.h(0, 20);
                this.a(this.ae, this.af + 20, true);
                n4 = 20;
                int n11 = 240 - (this.m_mapWidth + 1 << 2);
                object = this;
                int n12 = 0;
                int n13 = 0;
                if (((a)object).var_boolean_arr_f[1] && ((a)object).var_javax_microedition_lcdui_Image_d != null) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).var_javax_microedition_lcdui_Image_d, n11, 20, 0);
                    n12 = n11 + (((a)object).playerXOffset << 2);
                    n13 = 20 + (((a)object).playerYOffest << 2);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(1112072);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(n12, n13, 4, 4);
                }
                this.e(0, this.var_int_W);
                this.void_d(0, 0);
                object = this;
                if (((a)object).var_boolean_n) {
                    if (((a)object).upperX >= 0) {
                        super.a(((a)object).gamePngImagesGroups[8][19], 104, 20, 0, 0, 16, 16);
                        super.a(((a)object).gamePngImagesGroups[8][19], 120, 20 + ((a)object).var_int_U, 16, 0, 15, 17);
                    }
                    if (((a)object).downY >= 0) {
                        super.a(((a)object).gamePngImagesGroups[8][19], 104, ((a)object).var_int_W - 17, 0, 17, 16, 16);
                        super.a(((a)object).gamePngImagesGroups[8][19], 120, ((a)object).var_int_W - 17 - ((a)object).var_int_U, 16, 17, 15, 17);
                    }
                }
                this.D();
                this.var_byte_n = 1;
                this.var_byte_o = (byte)3;
                this.m();
                break;
            }
            case 4:
            case 19: {
                int n6;
                int n9;
                this.void_a(true);
                this.e(0, this.var_int_W);
                this.void_d(0, 0);
                n4 = 160;
                int n14 = 120;
                object = this;
                int n15 = ((a)object).var_int_i + 22;
                int n16 = ((a)object).var_int_o + 32;
                int n17 = 120 - (((a)object).var_int_i + 22 >> 1);
                n2 = 160 - (((a)object).var_int_o + 32 >> 1);
                n = ((a)object).var_int_p - ((a)object).var_int_b >> 1;
                boolean bl = false;
                super.c(n17, n2, n15, n16);
                n2 += 16 + n;
                int n18 = ((a)object).var_int_l;
                while (n18 < ((a)object).var_int_m) {
                    byte by = ((a)object).var_byte_arr_a[n18];
                    if (((a)object).var_int_k == n18) {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0);
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(120 - (((a)object).var_int_i >> 1), n2 - n, ((a)object).var_int_i, ((a)object).var_int_p);
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(16377897);
                    } else if (by != 11) {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(7574946);
                    } else {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0xFF99FF);
                    }
                    if (by > 11 && by < 17) {
                        int n19 = 4;
                        n6 = n2;
                        n9 = 120;
                        int[] nArray = ((a)object).var_int_arr_G;
                        String string = ((a)object).var_java_lang_String_arr_c[by];
                        Object object3 = object;
                        n4 = string.length();
                        int n20 = ((a)object3).var_byte_z;
                        int n21 = nArray.length;
                        char c = '\u0000';
                        n9 -= ((a)object3).var_javax_microedition_lcdui_Font_a.stringWidth(string) >> 1;
                        for (int i = 0; i < n4; ++i) {
                            c = string.charAt(i);
                            ((a)object3).var_javax_microedition_lcdui_Graphics_a.setColor(nArray[n20]);
                            ((a)object3).var_javax_microedition_lcdui_Graphics_a.drawChar(c, n9, n6, 0);
                            n9 += ((a)object3).var_javax_microedition_lcdui_Font_a.charWidth(c);
                            if (++n20 < n21) continue;
                            n20 = 0;
                        }
                        if ((((a)object3).var_int_d & 3) == 0 && (((a)object3).var_byte_z = (byte)(((a)object3).var_byte_z + 1)) >= n21) {
                            ((a)object3).var_byte_z = 0;
                        }
                    } else {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString(((a)object).var_java_lang_String_arr_c[by], 120, n2, 17);
                    }
                    ++n18;
                    n2 += ((a)object).var_int_p;
                }
                n3 = 120 + (n15 >> 1) - 23;
                n2 = 160 + (n16 >> 1) - 38;
                if (((a)object).var_int_l > 0) {
                    super.a(((a)object).gamePngImagesGroups[8][15], n3, n2, 0, 0, 7, 9);
                }
                if (((a)object).var_int_m < ((a)object).var_int_h) {
                    super.a(((a)object).gamePngImagesGroups[8][15], n3, n2 + 9, 7, 0, 7, 9);
                }
                this.m();
                break;
            }
            case 5: {
                this.void_a(false);
                object = this;
                int n22 = 240 - ((a)object).be >> 1;
                n4 = 320 - ((a)object).bd >> 1;
                Image image = null;
                byte by = 0;
                n3 = 0;
                n2 = 0;
                n = 0;
                if (((a)object).bg - ((a)object).bf > 0) {
                    super.c(n22, n4, ((a)object).be, ((a)object).bd);
                    if (((a)object).bf > 0) {
                        super.a(((a)object).gamePngImagesGroups[8][19], 112, n4 - 17 - (((a)object).var_int_d & 1), 16, 0, 15, 17);
                    }
                    n4 += 16;
                    int n23 = ((a)object).bf;
                    int n24 = n22 += 16;
                    while (n23 < ((a)object).bg) {
                        by = ((a)object).var_byte_arr_u[n23];
                        image = ((a)object).actorSpriteImages[((a)object).var_byte_arr_u[n23]];
                        n3 = ((a)object).var_int_arr_w[n23];
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(13097429);
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString(((a)object).var_java_lang_String_arr_m[by], n22, n4 + 2, 0);
                        n22 = (240 + ((a)object).be >> 1) - 75;
                        n = ((a)object).var_int_b - 19 >> 1;
                        n4 += n;
                        if (n3 < 0) {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][17], n22 - 4, n4 + 2, 0);
                        } else {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][16], n22 - 12, n4 + 2, 0);
                            super.d((n22 += 15) - 1, n4 + 6, 48, 12);
                            super.int_a(((a)object).gamePngImagesGroups[8][2], n3, n22 + 45, n4 + 8);
                        }
                        n22 = n24;
                        super.d(n22, n4 += n + 19 + 4, 32, 32);
                        if (by > 40) {
                            n2 = 32 - ((a)object).var_byte_arr_h[by] >> 1;
                            n = image.getHeight();
                            if (n > 31) {
                                n = 31;
                            }
                            if (n2 < 0) {
                                super.a(image, n22, n4 + 31 - n, -n2, 0, 32, n);
                            } else {
                                super.a(image, n22 + n2, n4 + 31 - n, 0, 0, ((a)object).var_byte_arr_h[by], n);
                            }
                        } else {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setClip(n22, n4, 32, 32);
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(image, n22 + (32 - image.getWidth() >> 1), n4 + (32 - image.getHeight() >> 1), 0);
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setClip(n22, n4, 240, 320);
                        }
                        super.a(((a)object).gamePngImagesGroups[8][7], n22 += 36, n4 += 4, 10, 0, 10, 13);
                        super.d(n22 += 15, n4, 48, 12);
                        super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).monsterAttackArray[by - 41], n22 + 40, n4 + 2);
                        super.a(((a)object).gamePngImagesGroups[8][7], n22 += 52, n4, 20, 2, 10, 10);
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(512);
                        super.d(n22 += 15, n4, 48, 12);
                        super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).monsterDefArray[by - 41], n22 + 40, n4 + 2);
                        super.a(((a)object).gamePngImagesGroups[8][7], n22 -= 82, (n4 += 12) + 5, 0, 2, 10, 10);
                        super.d(n22 += 15, n4 + 5, 48, 12);
                        super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).monsterHpArray[by - 41], n22 + 40, n4 + 7);
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][1], n22 += 52, n4 + 5, 0);
                        super.d(n22 += 15, n4 + 5, 48, 12);
                        super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).monsterMoneyLookupTable[by - 41], n22 += 40, n4 + 7);
                        n4 += 18;
                        if (++n23 < ((a)object).bg) {
                            n22 = n24 - 5;
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(6435);
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.drawLine(n22, n4, n22 + ((a)object).be - 22, n4);
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(4803902);
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.drawLine(n22, ++n4, n22 + ((a)object).be - 22, n4);
                        }
                        n4 += 2;
                        n22 = n24;
                    }
                    n4 += 16;
                    if (((a)object).bg < ((a)object).bb) {
                        super.a(((a)object).gamePngImagesGroups[8][19], 112, n4 + (((a)object).var_int_d & 1), 16, 17, 15, 17);
                    }
                }
                this.m();
                break;
            }
            case 7: {
                this.void_a(false);
                this.b(true);
                this.m();
                break;
            }
            case 8: {
                this.void_a(false);
                this.b(false);
                this.m();
                break;
            }
            case 9: {
                this.void_a(true);
                this.h(0, 20);
                this.a(this.ae, this.af + 20, true);
                this.e(0, this.var_int_W);
                this.void_d(0, 0);
                this.m();
                object = this;
                int n25 = 240 - ((a)object).ax - 22 >> 1;
                n4 = 320 - ((a)object).aw >> 1;
                int n26 = (((a)object).var_int_a << 1) + 16 + 48;
                super.a(0, n25, n4, ((a)object).ax + 22, ((a)object).aw);
                n25 = 240 - n26 >> 1;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(7575203);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString("花费", n25, n4 += 21, 0);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][1], n25 += (((a)object).var_int_a << 1) + 4, n4 + (((a)object).var_int_b - 10 >> 1), 0);
                super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).ay, n25 += 60, n4 + 3 + (((a)object).var_int_b - 10 >> 1));
                n25 = 240 - ((a)object).ax >> 1;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(549016);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(n25, (n4 += ((a)object).var_int_b + 5) + (((a)object).aC << 4), ((a)object).ax, 16);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][14], n25 + 10, n4 + 2 + (((a)object).aC << 4), 0);
                super.void_a(((a)object).gamePngImagesGroups[8][14], n25 + ((a)object).ax - 30, n4 + 2 + (((a)object).aC << 4), 1);
                super.a(((a)object).gamePngImagesGroups[8][7], 97, n4 + 4, 0, 2, 10, 10);
                super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).az, 142, n4 + 6);
                super.a(((a)object).gamePngImagesGroups[8][7], 97, (n4 += 16) + 4, 11, 0, 8, 13);
                super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).aA, 142, n4 + 6);
                super.a(((a)object).gamePngImagesGroups[8][7], 97, (n4 += 16) + 4, 20, 2, 10, 11);
                super.int_a(((a)object).gamePngImagesGroups[8][2], ((a)object).aB, 142, n4 + 6);
                break;
            }
            case 10: {
                int n27 = 320;
                int n28 = 240;
                n4 = 0;
                int n29 = 0;
                object = this;
                for (n3 = 319; n3 >= 1; n3 -= 2) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawLine(-1, -1 + (320 - n3), -1 + n3 - 1, 318);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawLine(239 - n3, -1, 239, -1 + n3);
                }
                object = this;
                n29 = 240 - ((a)object).aZ >> 1;
                n4 = 320 - ((a)object).aY >> 1;
                n28 = 0;
                Image image = null;
                super.c(n29, n4, ((a)object).aZ, ((a)object).aY);
                n29 += 20;
                n4 += 16;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(13097429);
                if (((a)object).ba < ((a)object).bagItemCount) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString(((a)object).var_java_lang_String_arr_m[((a)object).playerBagArray[((a)object).ba]], n29, n4 + 2, 0);
                }
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(6178);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawLine(n29 -= 9, n4 += ((a)object).var_int_b + 4, n29 + ((a)object).aZ - 23, n4);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(3564144);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawLine(n29, ++n4, n29 + ((a)object).aZ - 23, n4);
                n4 += 10;
                n28 = n29 += 9;
                n3 = ((a)object).aU;
                n2 = ((a)object).aT * ((a)object).aU;
                while (n3 < ((a)object).aV) {
                    n = 0;
                    while (n < ((a)object).aT) {
                        super.d(n29, n4, 32, 32);
                        if (n2 == ((a)object).ba) {
                            super.a(((a)object).gamePngImagesGroups[2][10], n29 - 4, n4 - 3, 38 * (((a)object).var_int_d & 1), 0, 38, 38);
                        }
                        if (n2 < ((a)object).bagItemCount) {
                            image = ((a)object).actorSpriteImages[((a)object).playerBagArray[n2]];
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(image, n29 + (32 - image.getWidth() >> 1), n4 + (32 - image.getHeight() >> 1), 0);
                            if (((a)object).itemCurrentUseContArray[n2] > 0) {
                                super.int_a(((a)object).gamePngImagesGroups[8][2], (int)((a)object).itemCurrentUseContArray[n2], n29 + 32, n4 + 26);
                            }
                        }
                        ++n;
                        n29 += 40;
                        ++n2;
                    }
                    ++n3;
                    n29 = n28;
                    n4 += 40;
                }
                n29 = (240 + ((a)object).aZ >> 1) - 22;
                n4 -= ((a)object).aY - 32 - ((a)object).var_int_b - 4 >> 1;
                if (((a)object).aU > 0) {
                    super.a(((a)object).gamePngImagesGroups[8][15], n29, n4 - 15, 0, 0, 7, 9);
                }
                if (((a)object).aV < ((a)object).aX) {
                    super.a(((a)object).gamePngImagesGroups[8][15], n29, n4 + 5, 7, 0, 7, 9);
                }
                this.m();
                break;
            }
            case 13: {
                this.void_a(false);
                break;
            }
            case 14: {
                object = this;
                int n30 = 0;
                if (((a)object).var_javax_microedition_lcdui_Image_b != null) {
                    ((a)object).var_int_r = ((a)object).var_javax_microedition_lcdui_Image_b.getHeight();
                    ((a)object).var_int_s = 320 - ((a)object).var_int_r - (((a)object).var_int_b + 4) * 3 >> 1;
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, ((a)object).var_int_s);
                    n30 = ((a)object).var_int_s + ((a)object).var_javax_microedition_lcdui_Image_b.getHeight();
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, n30, 240, 320 - n30);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).var_javax_microedition_lcdui_Image_b, 120, ((a)object).var_int_s, 17);
                    if (!((a)object).var_boolean_d) {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    } else {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(((a)object).var_int_arr_c[((a)object).var_byte_e]);
                    }
                    if (((a)object).var_int_t < 3 && ((a)object).var_java_lang_String_b != null) {
                        super.a(((a)object).var_java_lang_String_b, 10, ((a)object).var_int_s + ((a)object).var_int_r + ((a)object).var_int_b, 220, ((a)object).var_int_I << 1, false);
                    }
                }
                if (((a)object).var_int_t > 2) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString("请按任意键", 120, 320 - ((a)object).var_int_b - 2, 17);
                } else {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString("跳过", 240 - ((a)object).var_javax_microedition_lcdui_Font_a.stringWidth("跳过") - 5, 320 - ((a)object).var_int_b - 2, 0);
                }
                this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
                this.F();
                this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
                break;
            }
            case 18: {
                object = this;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0);
                ((a)object).var_byte_v = 0;
                ((a)object).var_short_arr_h = new short[64];
                ((a)object).var_short_arr_i = new short[64];
                int n31 = 0;
                n4 = 0;
                short s = 0;
                int n32 = ((a)object).var_byte_u;
                while (--n32 >= 0) {
                    n4 = ((a)object).var_short_arr_f[n32];
                    s = ((a)object).var_short_arr_g[n32];
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(n4, (int)s, 4, 4);
                    n31 = super.int_g(15);
                    if ((n31 & 1) != 0) {
                        super.m(n4, s - 4);
                    }
                    if ((n31 & 2) != 0) {
                        super.m(n4, s + 4);
                    }
                    if ((n31 & 4) != 0) {
                        super.m(n4 - 4, s);
                    }
                    if ((n31 & 8) == 0) continue;
                    super.m(n4 + 4, s);
                }
                ((a)object).var_byte_u = ((a)object).var_byte_v;
                ((a)object).var_short_arr_f = ((a)object).var_short_arr_h;
                ((a)object).var_short_arr_g = ((a)object).var_short_arr_i;
                break;
            }
            case 12: {
                this.void_a(false);
                object = this;
                int n33 = 320 - ((a)object).var_int_b - 4;
                super.a(((a)object).var_java_lang_String_e, 120, n33 + 2, 17, ((a)object).var_int_arr_K);
                n33 += ((a)object).var_int_b + 4 - 13 >> 1;
                if (((a)object).level > 0) {
                    super.void_a(((a)object).gamePngImagesGroups[8][14], 60 - ((a)object).var_int_U, n33, 1);
                }
                if (((a)object).level < ((a)object).aL - 1) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][14], 160 + ((a)object).var_int_U, n33, 0);
                }
                this.m();
                break;
            }
            case 15: {
                this.void_a(false);
                this.b(this.gamePngImagesGroups[10][1], 86, 10, 0, 51, 68, 17, 17);
                this.m();
                break;
            }
            case 17: {
                this.void_a(false);
                this.b(this.gamePngImagesGroups[10][1], 86, 10, 0, 68, 68, 17, 17);
                this.m();
                break;
            }
            case 16: {
                this.void_a(false);
                object = this;
                int n34 = 240 - ((a)object).aG - 22 >> 1;
                n4 = 320 - ((a)object).aH >> 1;
                String string = null;
                super.b(((a)object).gamePngImagesGroups[10][1], 86, 10, 0, 34, 68, 17, 17);
                super.c(n34, n4, ((a)object).aG + 22, ((a)object).aH);
                int n35 = (((a)object).var_int_b + 8) * ((a)object).aE;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(549016);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(n34 += 11, (n4 += 16) + n35, ((a)object).aG, ((a)object).var_int_b + 8);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[8][14], n34 + 10, n4 + 2 + n35 + (((a)object).var_int_b - 5 >> 1), 0);
                super.void_a(((a)object).gamePngImagesGroups[8][14], n34 + ((a)object).aG - 30, n4 + 2 + n35 + (((a)object).var_int_b - 5 >> 1), 1);
                n3 = 0;
                while (n3 < ((a)object).aF) {
                    string = ((a)object).var_java_lang_String_arr_f[((a)object).var_byte_arr_l[n3]];
                    n34 = 240 - ((a)object).var_javax_microedition_lcdui_Font_a.stringWidth(string) - 16 >> 1;
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString(string, n34, n4 + 4, 0);
                    n34 += 2 + ((a)object).var_javax_microedition_lcdui_Font_a.stringWidth(string);
                    if (!((a)object).var_boolean_arr_f[n3]) {
                        super.a(((a)object).gamePngImagesGroups[8][11], n34, n4 + (((a)object).var_int_b - 2 >> 1), 12, 0, 12, 10);
                    } else {
                        super.a(((a)object).gamePngImagesGroups[8][11], n34, n4 + (((a)object).var_int_b - 2 >> 1), 0, 0, 12, 10);
                    }
                    ++n3;
                    n4 += ((a)object).var_int_b + 8;
                }
                this.m();
                break;
            }
            case 20: {
                object = this;
                int n36 = 320 - ((a)object).gamePngImagesGroups[14][0].getHeight() >> 1;
                ((a)object).var_int_x += 2;
                if (!((a)object).var_boolean_e && (((a)object).var_int_d & 1) != 0 && ++((a)object).var_int_w > ((a)object).gamePngImagesGroups[14][0].getWidth() - 240) {
                    ((a)object).var_boolean_e = true;
                }
                if ((((a)object).var_int_d & 3) >> 1 != 0 && ((a)object).var_int_H < ((a)object).var_java_lang_String_arr_o[260].length()) {
                    ++((a)object).var_int_H;
                    super.a(((a)object).var_java_lang_String_arr_o[260], 209, (((a)object).var_int_I << 1) + 12, ((a)object).var_int_H);
                    ((a)object).var_int_A = ((a)object).var_int_C - 1;
                    if (((a)object).var_int_A < 0) {
                        ((a)object).var_int_A = 0;
                    }
                    ((a)object).var_int_B = ((a)object).var_int_C;
                }
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(3156024);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, n36);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(0, 320 - n36, 240, n36);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[14][0], -((a)object).var_int_w, n36, 0);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                super.a(((a)object).var_java_lang_String_arr_o[260], 15, 320 - ((a)object).var_int_b - 10, 210, ((a)object).var_int_b + 10, false);
                break;
            }
            case 22: {
                this.H();
                break;
            }
            case 99: {
                object = this;
                int n37 = ((a)object).cj & 7;
                n4 = 20;
                n3 = 0;
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0xF8F8F8);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(18, 138, 204, 44);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawRect(20, 140, 199, 39);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawRect(18, 138, 203, 43);
                if (!((a)object).var_boolean_G) {
                    if (n37 == 7) {
                        ((a)object).var_boolean_G = true;
                    }
                } else {
                    if (n37 == 7) {
                        ((a)object).var_boolean_G = false;
                    }
                    n37 = 7 - n37;
                }
                n2 = 0;
                while (n2 < 8) {
                    n3 = !((a)object).var_boolean_G ? n37 - n2 : n2 - n37;
                    switch (n3) {
                        case 0: {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(44527);
                            break;
                        }
                        case 1: {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0x66CCFF);
                            break;
                        }
                        case 2: {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(11593215);
                            break;
                        }
                        default: {
                            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0xD9D9D9);
                        }
                    }
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(n4 + 2, 142, 21, 6);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(215 - n4 + 2, 172, 21, 6);
                    ++n2;
                    n4 += 25;
                }
                ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(44527);
                ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString(((a)object).var_java_lang_String_h, 120, 320 - ((a)object).var_int_b >> 1, 17);
            }
        }
        if (this.var_boolean_q) {
            object = this;
            int n38 = 0;
            int n39 = 0;
            n3 = 0;
            if (((a)object).var_boolean_r) {
                if (++((a)object).bM > 4) {
                    ((a)object).bM = 4;
                    ((a)object).var_boolean_r = false;
                    ((a)object).level = ((a)object).var_byte_x;
                    super.s(((a)object).level);
                    if (((a)object).level == 0) {
                        super.void_a(1, 2);
                        super.i((((a)object).preferWidth - 32 >> 1) - ((a)object).playerPixelX, (((a)object).perferHeight - 32 >> 1) - ((a)object).playerPixelY);
                    } else if (((a)object).level == 50) {
                        super.void_a(6, 7);
                        super.i((((a)object).preferWidth - 32 >> 1) - ((a)object).playerPixelX, (((a)object).perferHeight - 32 >> 1) - ((a)object).playerPixelY);
                    } else if (((a)object).level == 1 && !((a)object).var_boolean_s) {
                        super.void_a(6, 11);
                        super.i((((a)object).preferWidth - 32 >> 1) - ((a)object).playerPixelX, (((a)object).perferHeight - 32 >> 1) - ((a)object).playerPixelY);
                    } else {
                        n2 = super.int_a(((a)object).var_boolean_s);
                        if (n2 >= 0) {
                            super.void_b(((a)object).mapObjectPixelX[n2] >> 5, ((a)object).mapObjectPixelY[n2] >> 5);
                        }
                    }
                    super.r();
                    super.k();
                }
            } else if (--((a)object).bM <= 0) {
                ((a)object).var_boolean_r = true;
                ((a)object).var_boolean_q = false;
            }
            n39 = n38 = 4 - ((a)object).bM;
            n3 = ((a)object).bM << 1;
            ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(0);
            n2 = 0;
            while (n2 < 40) {
                n = 0;
                while (n < 30) {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.fillRect(n38, n39, n3, n3);
                    ++n;
                    n38 += 8;
                }
                ++n2;
                n38 = 4 - ((a)object).bM;
                n39 += 8;
            }
            return;
        }
        if (this.var_boolean_f) {
            n4 = 320 - this.var_int_z >> 1;
            n5 = 240 - this.var_int_y >> 1;
            object = this;
            int n40 = n5;
            int n41 = n4;
            super.c(n5, n4, ((a)object).var_int_y, ((a)object).var_int_z);
            switch (((a)object).var_byte_i) {
                case 0:
                case 2:
                case 4:
                case 5: {
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    super.a(((a)object).var_java_lang_String_c, n40 += 16, n41 += 16, 180, 240, true);
                    break;
                }
                case 1:
                case 3: {
                    super.d(n40 += 16, n41 += 16, 32, 32);
                    Image image = ((a)object).actorSpriteImages[((a)object).playerCurrentEquipItemId];
                    if (image != null) {
                        ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(image, n40 + (32 - image.getWidth() >> 1), n41 + (32 - image.getHeight() >> 1), 0);
                    }
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(16770173);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawString(((a)object).var_java_lang_String_arr_m[((a)object).playerCurrentEquipItemId], n40 += 42, n41 + (32 - ((a)object).var_int_b >> 1), 0);
                    ((a)object).var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    n40 = n5 + 16;
                    super.a(((a)object).var_java_lang_String_c, n40, n41 += 36, 180, ((a)object).var_int_z - 32 - 36, true);
                }
            }
            n41 = n4 + ((a)object).var_int_z - 12 - 18;
            if (((a)object).var_byte_f != 0) {
                n40 = n5 + 13;
                super.a(((a)object).gamePngImagesGroups[8][11], n40, n41 + 6, (((a)object).var_byte_f - 1) * 12, 0, 12, 10);
            }
            if (((a)object).var_byte_g != 0) {
                n40 = n5 + ((a)object).var_int_y - 25;
                super.a(((a)object).gamePngImagesGroups[8][11], n40, n41 + 6, (((a)object).var_byte_g - 1) * 12, 0, 12, 10);
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Unable to fully structure code
     */
    public final void run() {
        if (this.var_boolean_F) {
            while ((var6_4 = this.int_e()) == 1) {
                Thread.yield();
            }
            this.var_java_lang_String_g = null;
            var1_6 = var6_4;
            var2_8 = this.var_java_lang_Object_a;
            synchronized (var2_8) {
                this.cf = var1_6;
                return;
            }
        }
        long var1_7 = 0L;
        long var3_10 = 0L;
        long var5_2 = 0L;
        try {
            while (this.var_boolean_a) {
                block271: {
                    block270: {
                        var1_7 = System.currentTimeMillis();
                        var3_10 = var1_7 + (long)this.var_int_c;
                        if (!this.var_boolean_f) break block270;
                        block4 : switch (this.var_byte_i) {
                            case 0: {
                                if (this.gameStateFlag == 15 || this.gameStateFlag == 17) {
                                    switch (this.var_int_f) {
                                        case -1: {
                                            this.boolean_a(this.var_int_A - this.var_int_E);
                                            break;
                                        }
                                        case -2: {
                                            this.boolean_a(this.var_int_A + this.var_int_E);
                                            break;
                                        }
                                        case -7: {
                                            this.var_boolean_f = false;
                                            this.gameStateFlag = this.var_byte_b;
                                        }
                                    }
                                    break;
                                }
                                this.g();
                                break;
                            }
                            case 4: {
                                switch (this.var_int_f) {
                                    case -6:
                                    case -5: {
                                        this.var_boolean_f = this.boolean_a(true);
                                        break block4;
                                    }
                                    case -7: {
                                        this.var_boolean_f = this.boolean_a(false);
                                        break block4;
                                    }
                                }
                                this.g();
                                break;
                            }
                            case 1: {
                                if (this.var_byte_g == 0 && this.var_byte_f == 0) {
                                    this.g();
                                    break;
                                }
                                block21 : switch (this.var_byte_g) {
                                    case 2:
                                    case 3: {
                                        switch (this.var_int_f) {
                                            case 0: {
                                                break block21;
                                            }
                                            case -2:
                                            case -1: {
                                                this.g();
                                                break block21;
                                            }
                                        }
                                        this.var_boolean_f = false;
                                    }
                                }
                                break;
                            }
                            case 3: {
                                switch (this.var_int_f) {
                                    case -6: {
                                        this.var_boolean_f = false;
                                        this.l(this.ba);
                                        break block4;
                                    }
                                    case -7: {
                                        this.gameStateFlag = (byte)10;
                                        this.var_boolean_f = false;
                                        break block4;
                                    }
                                }
                                this.g();
                                break;
                            }
                            case 2: {
                                break;
                            }
                            case 5: {
                                switch (this.var_int_f) {
                                    case 0: {
                                        break block4;
                                    }
                                    case -1: {
                                        this.boolean_a(this.var_int_A - 1);
                                        break block4;
                                    }
                                    case -2: {
                                        this.boolean_a(this.var_int_A + 1);
                                        break block4;
                                    }
                                    case -3: {
                                        this.i(this.level - 1);
                                        break block4;
                                    }
                                    case -4: {
                                        this.i(this.level + 1);
                                        break block4;
                                    }
                                    case -7:
                                    case -6:
                                    case -5: {
                                        this.var_boolean_f = false;
                                        this.gameStateFlag = (byte)10;
                                    }
                                }
                            }
                        }
                        this.pressedKeyCode = 0;
                        this.var_int_f = 0;
                        break block271;
                    }
                    switch (this.gameStateFlag) {
                        case 0: {
                            this.var_int_c = 100;
                            if (this.var_int_e >= 2)  break lbl128;
                            if (this.ca != 0) break lbl124;
                            try {
                                this.var_javax_microedition_lcdui_Image_a = Image.createImage((String)("/l" + this.var_int_e + ".png"));
                            }
                            catch (Exception v0) {}
                            if (this.var_javax_microedition_lcdui_Image_a == null) {
                                this.ca = 0;
                                ++this.var_int_e;
                                break;
                            }
                            this.ca = 1;
                            break;
                            lbl124:
                            // 1 sources

                            if (++this.ca <= 15) break;
                            ++this.var_int_e;
                            this.ca = 0;
                            break;
                            lbl128:
                            // 1 sources

                            if (++this.ca <= 35) {
                                this.n(0, this.ca);
                                break;
                            }
                            this.v(-1);
                            this.var_boolean_E = false;
                            this.ca = 0;
                            this.var_javax_microedition_lcdui_Image_a = null;
                            this.gamePngImagesGroups[0] = null;
                            this.G();
                            this.var_int_c = 75;
                            this.gameStateFlag = (byte)21;
                            this.void_a();
                            break;
                        }
                        case 21: {
                            switch (this.var_int_f) {
                                case -6: {
                                    this.var_boolean_D = true;
                                    if (this.bZ == 0) {
                                        this.bZ = 60;
                                    }
                                    this.gameStateFlag = 1;
                                    this.void_a();
                                    break;
                                }
                                case -7: {
                                    this.var_boolean_D = false;
                                    this.bZ = 0;
                                    this.gameStateFlag = 1;
                                    this.void_a();
                                }
                            }
                            break;
                        }
                        case 1: {
                            if ((this.var_int_d & 3) == 0) {
                                this.e(this.int_g(240), 320 - this.var_int_q - this.int_g(150), 2, -1);
                            }
                            this.o();
                            block66 : switch (this.var_int_f) {
                                case -3:
                                case -1:
                                case 50:
                                case 52: {
                                    if (this.var_int_k > 0) {
                                        --this.var_int_k;
                                        break;
                                    }
                                    this.var_int_k = this.var_int_h - 1;
                                    break;
                                }
                                case -4:
                                case -2:
                                case 54:
                                case 56: {
                                    if (this.var_int_k < this.var_int_h - 1) {
                                        ++this.var_int_k;
                                        break;
                                    }
                                    this.var_int_k = 0;
                                    break;
                                }
                                case -5:
                                case 53: {
                                    switch (this.var_byte_arr_a[this.var_int_k]) {
                                        case 0: {
                                            this.gamePngImagesGroups[10][0] = null;
                                            this.gameStateFlag = (byte)14;
                                            this.void_a();
                                            break block66;
                                        }
                                        case 1: {
                                            this.gameStateFlag = (byte)8;
                                            this.var_byte_b = 1;
                                            this.void_a();
                                            break block66;
                                        }
                                        case 2: {
                                            this.gameStateFlag = (byte)16;
                                            this.var_byte_b = 1;
                                            this.void_a();
                                            break block66;
                                        }
                                        case 3: {
                                            this.gameStateFlag = (byte)15;
                                            this.var_byte_b = 1;
                                            this.void_a();
                                            break block66;
                                        }
                                        case 4: {
                                            this.gameStateFlag = (byte)17;
                                            this.var_byte_b = 1;
                                            this.void_a();
                                            break block66;
                                        }
                                        case 5: {
                                            this.gameStateFlag = (byte)22;
                                            this.void_a();
                                        }
                                    }
                                }
                            }
                            break;
                        }
                        case 2: {
                            if (this.bN < 100) {
                                if (this.bN < this.bQ) {
                                    this.bN += 4;
                                    break;
                                }
                                byte var8_17 = this.var_byte_arr_P[this.bP];
                                switch (var8_17) {
                                    case 0: {
                                        this.void_a(8);
                                        break;
                                    }
                                    case 1: {
                                        this.void_a(10);
                                        break;
                                    }
                                    case 2: {
                                        this.void_a(2);
                                        break;
                                    }
                                    case 3: {
                                        this.void_a(1);
                                        break;
                                    }
                                    case 4: {
                                        this.void_a(3);
                                        break;
                                    }
                                    case 5: {
                                        this.void_a(6);
                                        this.void_a(4);
                                        this.void_a(5);
                                        break;
                                    }
                                    case 13: {
                                        this.void_a(7);
                                        this.void_a(13);
                                        this.n();
                                        break;
                                    }
                                    case 6: {
                                        this.void_a(12);
                                        break;
                                    }
                                    case 7: {
                                        this.E();
                                        break;
                                    }
                                    case 8: {
                                        this.an = 51;
                                        this.level = 51;
                                        this.ao = 51;
                                        this.playerHp = 300;
                                        this.playerAttack = 10;
                                        this.playerAmaor = 10;
                                        this.redKeyCount = 0;
                                        this.blueKeyCount = 0;
                                        this.yellowKeyCount = 0;
                                        this.var_boolean_v = false;
                                        this.var_boolean_w = false;
                                        this.var_boolean_u = false;
                                        break;
                                    }
                                    case 12: {
                                        this.v();
                                        break;
                                    }
                                    case 10: {
                                        this.loadLevel(this.level);
                                        this.r();
                                        break;
                                    }
                                    case 9: {
                                        this.C();
                                        break;
                                    }
                                    case 11: {
                                        this.void_a(3);
                                        this.var_javax_microedition_lcdui_Image_c = this.gamePngImagesGroups[3][0];
                                        this.var_int_arr_d = this.var_int_arr_arr_b[0];
                                        this.var_int_M = 0;
                                        this.var_byte_m = 0;
                                        this.i((this.preferWidth - 32 >> 1) - this.playerPixelX, (this.perferHeight - 32 >> 1) - this.playerPixelY);
                                        break;
                                    }
                                    case 14: {
                                        this.void_a(11);
                                        break;
                                    }
                                    case 15: {
                                        this.void_a(14);
                                        break;
                                    }
                                    case 16: {
                                        if (this.boolean_e(this.bE)) break;
                                        this.bO = 0;
                                        this.gameStateFlag = (byte)8;
                                        this.void_a();
                                    }
                                }
                                ++this.bP;
                                this.bQ = this.bP * 100 / this.bO;
                                if (this.bQ > this.bN) break;
                                this.bQ = this.bN + 1;
                                break;
                            }
                            this.bN = 0;
                            this.bQ = 0;
                            this.gamePngImagesGroups[15] = null;
                            this.gameStateFlag = this.var_byte_y;
                            if (!this.var_boolean_t) break;
                            this.void_a();
                            break;
                        }
                        case 3: {
                            switch (this.var_int_f) {
                                case -6: {
                                    this.gameStateFlag = (byte)10;
                                    this.void_a();
                                    break;
                                }
                                case -7: {
                                    this.var_byte_c = this.gameStateFlag;
                                    this.gameStateFlag = (byte)4;
                                    this.void_a();
                                }
                            }
                            block102 : switch (this.var_byte_l) {
                                case 5: {
                                    this.c(true);
                                    break;
                                }
                                case 0: {
                                    if (this.var_boolean_B) {
                                        this.l();
                                        break;
                                    }
                                    this.j();
                                    break;
                                }
                                case 1: {
                                    switch (this.var_byte_m) {
                                        case 1: {
                                            this.playerPixelY -= 8;
                                            if (this.playerPixelY + this.af + 16 >= 106) break;
                                            this.i(this.ae, this.af + 8);
                                            break;
                                        }
                                        case 0: {
                                            this.playerPixelY += 8;
                                            if (this.playerPixelY + this.af + 16 <= this.perferHeight - 106) break;
                                            this.i(this.ae, this.af - 8);
                                            break;
                                        }
                                        case 3: {
                                            this.playerPixelX -= 8;
                                            if (this.playerPixelX + this.ae + 16 >= 106) break;
                                            this.i(this.ae + 8, this.af);
                                            break;
                                        }
                                        case 2: {
                                            this.playerPixelX += 8;
                                            if (this.playerPixelX + this.ae + 16 <= this.preferWidth - 106) break;
                                            this.i(this.ae - 8, this.af);
                                        }
                                    }
                                    this.var_int_R += 8;
                                    this.h();
                                    if (this.var_int_R < 32) break;
                                    this.var_int_R = 0;
                                    this.var_int_M = 0;
                                    this.k();
                                    break;
                                }
                                case 2: {
                                    this.i();
                                    if (!this.var_boolean_g) {
                                        switch (this.pressedKeyCode) {
                                            case -1:
                                            case 50: {
                                                this.var_byte_m = 1;
                                                this.af += 16;
                                                this.i(this.ae, this.af);
                                                break;
                                            }
                                            case -2:
                                            case 56: {
                                                this.var_byte_m = 0;
                                                this.af -= 16;
                                                this.i(this.ae, this.af);
                                                break;
                                            }
                                            case -3:
                                            case 52: {
                                                this.var_byte_m = (byte)3;
                                                this.ae += 16;
                                                this.i(this.ae, this.af);
                                                break;
                                            }
                                            case -4:
                                            case 54: {
                                                this.var_byte_m = (byte)2;
                                                this.ae -= 16;
                                                this.i(this.ae, this.af);
                                            }
                                        }
                                        switch (this.var_int_f) {
                                            case -5:
                                            case 53: {
                                                this.var_boolean_g = true;
                                                this.int_e(0);
                                            }
                                        }
                                        break;
                                    }
                                    this.x();
                                    break;
                                }
                                case 3: {
                                    switch (this.var_int_f) {
                                        case -3: {
                                            if (this.bagItemCount > 0) {
                                                if (this.aS > 0) {
                                                    this.aS = 0;
                                                    break block102;
                                                }
                                                this.aS = this.bagItemCount - 1;
                                                break block102;
                                            }
                                            break lbl408;
                                        }
                                        case -4: {
                                            if (this.bagItemCount > 0) {
                                                if (this.aS < this.bagItemCount - 1) {
                                                    ++this.aS;
                                                    break block102;
                                                }
                                                this.aS = 0;
                                                break block102;
                                            }
                                            break lbl408;
                                        }
                                        case -6:
                                        case -5: {
                                            this.l(this.aS);
                                        }
                                        case -7: {
                                            this.var_byte_l = 0;
                                        }
                                    }
                                }
                            }
                            lbl408:
                            // 16 sources

                            this.q();
                            break;
                        }
                        case 4: {
                            switch (this.var_int_f) {
                                case -1: {
                                    if (this.var_int_k > 0) {
                                        --this.var_int_k;
                                        if (this.var_int_k >= this.var_int_l) break;
                                        --this.var_int_l;
                                        --this.var_int_m;
                                        break;
                                    }
                                    this.var_int_k = this.var_int_h - 1;
                                    this.var_int_m = this.var_int_h;
                                    this.var_int_l = this.var_int_m - this.var_int_n;
                                    if (this.var_int_l >= 0) break;
                                    this.var_int_l = 0;
                                    break;
                                }
                                case -2: {
                                    if (this.var_int_k < this.var_int_h - 1) {
                                        ++this.var_int_k;
                                        if (this.var_int_k < this.var_int_m) break;
                                        ++this.var_int_m;
                                        ++this.var_int_l;
                                        break;
                                    }
                                    this.var_int_k = 0;
                                    this.var_int_l = 0;
                                    this.var_int_m = this.var_int_h;
                                    if (this.var_int_h <= this.var_int_n) break;
                                    this.var_int_m = this.var_int_n;
                                    break;
                                }
                                case -6:
                                case -5: {
                                    this.void_e();
                                    break;
                                }
                                case -7: {
                                    this.gameStateFlag = this.var_byte_c;
                                }
                            }
                            break;
                        }
                        case 5: {
                            switch (this.var_int_f) {
                                case -1: {
                                    this.m(this.bf - 1);
                                    break;
                                }
                                case -2: {
                                    this.m(this.bf + 1);
                                    break;
                                }
                                case -3: {
                                    break;
                                }
                                case -4: {
                                    break;
                                }
                                case -7:
                                case -6: {
                                    this.gameStateFlag = (byte)3;
                                }
                            }
                            break;
                        }
                        case 7:
                        case 8: {
                            switch (this.var_int_f) {
                                case -1: {
                                    if (this.bE > 0) {
                                        if (--this.bE >= this.bC) break;
                                        --this.bC;
                                        --this.bD;
                                        break;
                                    }
                                    this.bE = 5;
                                    this.bD = 6;
                                    this.bC = 6 - this.bG;
                                    break;
                                }
                                case -2: {
                                    if (this.bE < 5) {
                                        if (++this.bE < this.bD) break;
                                        ++this.bD;
                                        ++this.bC;
                                        break;
                                    }
                                    this.bE = 0;
                                    this.bC = 0;
                                    this.bD = this.bG;
                                    break;
                                }
                                case -6:
                                case -5: {
                                    if (this.gameStateFlag == 7) {
                                        this.r(this.level);
                                        this.q(this.bE);
                                        this.a((byte)0, "保存成功！", (byte)0, (byte)0);
                                        break;
                                    }
                                    if (this.gameStateFlag != 8 || !this.var_boolean_arr_h[this.bE]) break;
                                    this.pressedKeyCode = 0;
                                    this.var_int_f = 0;
                                    this.gamePngImagesGroups[10][0] = null;
                                    this.a((byte)3, true);
                                    this.u(6);
                                    this.u(8);
                                    this.u(5);
                                    this.u(13);
                                    this.u(9);
                                    this.u(16);
                                    this.u(10);
                                    this.u(2);
                                    this.u(3);
                                    this.u(11);
                                    break;
                                }
                                case -7: {
                                    this.gameStateFlag = this.var_byte_b;
                                }
                            }
                            break;
                        }
                        case 9: {
                            switch (this.var_int_f) {
                                case -1: {
                                    if (this.aC > 0) {
                                        --this.aC;
                                        break;
                                    }
                                    this.aC = 2;
                                    break;
                                }
                                case -2: {
                                    if (this.aC < 2) {
                                        ++this.aC;
                                        break;
                                    }
                                    this.aC = 0;
                                    break;
                                }
                                case -6:
                                case -5: {
                                    if (this.aQ >= this.ay) {
                                        this.aQ -= this.ay;
                                        switch (this.aC) {
                                            case 0: {
                                                this.playerHp += this.az;
                                                break;
                                            }
                                            case 1: {
                                                this.playerAttack += this.aA;
                                                break;
                                            }
                                            case 2: {
                                                this.playerAmaor += this.aB;
                                            }
                                        }
                                        ++this.ar;
                                        this.ay = a.int_b(this.ar + 1);
                                        break;
                                    }
                                    this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                    break;
                                }
                                case -7: {
                                    this.gameStateFlag = (byte)3;
                                }
                            }
                            break;
                        }
                        case 10: {
                            block160 : switch (this.var_int_f) {
                                case -1: {
                                    if (this.ba >= this.aT) {
                                        this.ba -= this.aT;
                                        if (this.ba / this.aT >= this.aU) break;
                                        --this.aU;
                                        --this.aV;
                                        break;
                                    }
                                    this.ba += (this.aX - 1) * this.aT;
                                    this.aV = this.aX;
                                    this.aU = this.aX - this.aW;
                                    break;
                                }
                                case -2: {
                                    if (this.ba < this.aT * (this.aX - 1)) {
                                        this.ba += this.aT;
                                        if (this.ba / this.aT < this.aV) break;
                                        ++this.aU;
                                        ++this.aV;
                                        break;
                                    }
                                    this.ba -= (this.aX - 1) * this.aT;
                                    this.aU = 0;
                                    this.aV = this.aW;
                                    break;
                                }
                                case -3: {
                                    if (this.ba % this.aT > 0) {
                                        --this.ba;
                                        break;
                                    }
                                    this.ba += this.aT - 1;
                                    break;
                                }
                                case -4: {
                                    if (this.ba % this.aT < this.aT - 1) {
                                        ++this.ba;
                                        break;
                                    }
                                    this.ba -= this.aT - 1;
                                    break;
                                }
                                case -6:
                                case -5: {
                                    if (this.ba >= this.bagItemCount) break;
                                    this.playerCurrentEquipItemId = this.playerBagArray[this.ba];
                                    switch (this.playerCurrentEquipItemId) {
                                        case 13:
                                        case 14: {
                                            this.gameStateFlag = (byte)3;
                                            this.useBagItem(this.playerCurrentEquipItemId);
                                            break block160;
                                        }
                                        case 15:
                                        case 23:
                                        case 24:
                                        case 25: {
                                            this.a((byte)3, this.var_java_lang_String_arr_k[a.itemTypeToUseCountOrder(this.playerCurrentEquipItemId)], (byte)0, (byte)3);
                                            break block160;
                                        }
                                    }
                                    this.a((byte)3, this.var_java_lang_String_arr_k[a.itemTypeToUseCountOrder(this.playerCurrentEquipItemId)], (byte)1, (byte)2);
                                    break;
                                }
                                case -7: {
                                    this.gameStateFlag = (byte)3;
                                }
                            }
                            break;
                        }
                        case 11: {
                            this.q();
                            this.x();
                            String var7_15 = '\u0000';
                            block172 : switch (this.var_byte_q) {
                                case 0: {
                                    if (this.bo > 0) {
                                        --this.bo;
                                        break;
                                    }
                                    this.a(this.var_java_lang_String_f, this.bm);
                                    break;
                                }
                                case 1:
                                case 6: {
                                    if (this.var_byte_q == 6 && !this.boolean_a()) break;
                                    if (this.var_int_H >= this.var_java_lang_String_c.length()) break lbl638;
                                    if (this.var_int_f == 0) break lbl623;
                                    this.a(this.var_java_lang_String_c, 129, (this.var_int_I << 1) + 12);
                                    this.var_int_H = this.int_a(this.var_int_H);
                                    break lbl633;
                                    lbl623:
                                    // 1 sources

                                    if ((this.var_int_d & 1) == 0) break lbl634;
                                    ++this.var_int_H;
                                    char var7_15 = this.var_java_lang_String_c.charAt(this.var_int_H - 1);
                                    if (var7_15 == '\\') {
                                        var7_15 = this.var_java_lang_String_c.charAt(this.var_int_H);
                                        if (var7_15 == 'c') {
                                            this.var_int_H += 8;
                                        } else if (var7_15 == 'r') {
                                            this.var_int_H += 2;
                                        }
                                    }
                                    lbl633:
                                    // 7 sources

                                    this.a(this.var_java_lang_String_c, 129, (this.var_int_I << 1) + 12, this.var_int_H);
                                    lbl634:
                                    // 2 sources

                                    if (this.var_int_C <= this.var_int_B) break;
                                    this.boolean_a(this.var_int_C - this.var_int_E);
                                    break;
                                    lbl638:
                                    // 1 sources

                                    switch (this.var_int_f) {
                                        case 0: {
                                            break block172;
                                        }
                                        case -1: {
                                            this.boolean_a(this.var_int_A - 1);
                                            break block172;
                                        }
                                        case -2: {
                                            this.boolean_a(this.var_int_A + 1);
                                            break block172;
                                        }
                                    }
                                    this.var_int_H = 1;
                                    this.n(this.bi + 1);
                                    if (this.var_byte_q != 6) break;
                                    this.l(this.bk, this.bl);
                                    break;
                                }
                                case 2: {
                                    this.y();
                                    break;
                                }
                                case 3: {
                                    if (this.var_boolean_q) break;
                                    switch (this.var_byte_l) {
                                        case 5: {
                                            this.c(this.var_boolean_o);
                                            break;
                                        }
                                        case 0: {
                                            if (this.bS > 0) {
                                                this.var_byte_m = this.var_byte_arr_Q[--this.bS];
                                                this.var_byte_l = 1;
                                                this.a(this.var_byte_m);
                                                break;
                                            }
                                            this.var_boolean_B = false;
                                            this.var_byte_q = 0;
                                            break;
                                        }
                                        case 1: {
                                            switch (this.var_byte_m) {
                                                case 1: {
                                                    this.playerPixelY -= 8;
                                                    break;
                                                }
                                                case 0: {
                                                    this.playerPixelY += 8;
                                                    break;
                                                }
                                                case 3: {
                                                    this.playerPixelX -= 8;
                                                    break;
                                                }
                                                case 2: {
                                                    this.playerPixelX += 8;
                                                }
                                            }
                                            this.var_int_R += 8;
                                            this.bv = this.playerPixelX;
                                            this.bw = this.playerPixelY;
                                            this.h();
                                            if (this.var_int_R < 32) break;
                                            this.var_int_R = 0;
                                            this.var_int_M = 0;
                                            this.var_byte_l = 0;
                                            this.playerXOffset = this.playerPixelX >> 5;
                                            this.playerYOffest = this.playerPixelY >> 5;
                                            this.k();
                                        }
                                    }
                                    break;
                                }
                                case 4: {
                                    if (!this.boolean_a()) break;
                                    this.gameStateFlag = (byte)3;
                                    break;
                                }
                                case 5: {
                                    if (!this.var_boolean_q || this.var_boolean_r) break;
                                    this.var_byte_q = 0;
                                }
                            }
                            break;
                        }
                        case 13: {
                            break;
                        }
                        case 14: {
                            this.void_f();
                            if ((this.var_int_d & 3) != 0) break;
                            this.e(this.int_g(240), 320 - this.var_int_q - this.int_g(150), 2, -1);
                            break;
                        }
                        case 12: {
                            this.o();
                            break;
                        }
                        case 19: {
                            switch (this.var_int_f) {
                                case -3:
                                case -1:
                                case 50:
                                case 52: {
                                    if (this.var_int_k > 0) {
                                        --this.var_int_k;
                                        break;
                                    }
                                    this.var_int_k = this.var_int_h - 1;
                                    break;
                                }
                                case -4:
                                case -2:
                                case 54:
                                case 56: {
                                    if (this.var_int_k < this.var_int_h - 1) {
                                        ++this.var_int_k;
                                        break;
                                    }
                                    this.var_int_k = 0;
                                    break;
                                }
                                case -5:
                                case 53: {
                                    break;
                                }
                                case -7: {
                                    this.gameStateFlag = (byte)4;
                                    this.void_a();
                                }
                            }
                            break;
                        }
                        case 15:
                        case 17: {
                            break;
                        }
                        case 16: {
                            switch (this.var_int_f) {
                                case -1: {
                                    if (--this.aE >= 0) break;
                                    this.aE = this.aF - 1;
                                    break;
                                }
                                case -2: {
                                    if (++this.aE <= this.aF - 1) break;
                                    this.aE = 0;
                                    break;
                                }
                                case -5:
                                case -4:
                                case -3: {
                                    this.var_boolean_arr_f[this.aE] = this.var_boolean_arr_f[this.aE] == false;
                                    switch (this.var_byte_arr_l[this.aE]) {
                                        case 0: {
                                            boolean v2 = this.var_boolean_D = this.var_boolean_D == false;
                                            if (this.var_boolean_D) {
                                                this.bZ = 60;
                                                if (!this.var_boolean_C) {
                                                    this.a((byte)2, -1);
                                                } else {
                                                    this.a((byte)3, -1);
                                                }
                                            } else {
                                                this.G();
                                            }
                                            this.z();
                                            break;
                                        }
                                        case 1: {
                                            if (!this.var_boolean_arr_f[1]) {
                                                this.var_javax_microedition_lcdui_Image_d = null;
                                                break;
                                            }
                                            if (this.var_byte_b != 4) break;
                                            this.r();
                                        }
                                    }
                                    break;
                                }
                                case -7:
                                case -6: {
                                    this.gameStateFlag = this.var_byte_b;
                                }
                            }
                            break;
                        }
                        case 20: {
                            if (!this.var_boolean_e || this.var_int_f == 0) break;
                            this.gameStateFlag = 1;
                            this.void_a();
                            break;
                        }
                        case 22: {
                            if (++this.ca <= 70) {
                                this.n(1, this.ca);
                                break;
                            }
                            this.var_boolean_a = false;
                            CMidlet.a();
                            break;
                        }
                        case 99: {
                            if (this.var_boolean_F) {
                                switch (this.var_int_f) {
                                    case -7: {
                                        this.I();
                                        this.var_boolean_F = false;
                                        this.gameStateFlag = 0;
                                    }
                                }
                                if (this.cj < 8) {
                                    ++this.cj;
                                    break;
                                }
                                if (!this.boolean_b()) break;
                                this.var_boolean_F = false;
                                break;
                            }
                            if (this.int_f() != 0 && this.int_f() != 3 && this.var_int_f == 0) break;
                            this.gameStateFlag = 0;
                        }
                    }
                    this.var_int_f = 0;
                }
                super.repaint();
                super.serviceRepaints();
                do {
                    Thread.yield();
                } while ((var5_2 = System.currentTimeMillis()) >= var1_7 && var5_2 < var3_10);
                ++this.var_int_d;
            }
            return;
        }
        catch (Exception v3) {
            v3.printStackTrace();
            return;
        }
    }

    private void void_a() {
        switch (this.gameStateFlag) {
            case 21: {
                a a2 = this;
                String string = "SKY_WAR";
                int n = 0;
                try {
                    int n2;
                    a2.var_javax_microedition_rms_RecordStore_a = RecordStore.openRecordStore((String)string, (boolean)false);
                    a2.var_javax_microedition_rms_RecordEnumeration_a = a2.var_javax_microedition_rms_RecordStore_a.enumerateRecords(null, null, false);
                    n = a2.var_javax_microedition_rms_RecordEnumeration_a.nextRecordId();
                    a2.var_byte_arr_B = a2.var_javax_microedition_rms_RecordStore_a.getRecord(n);
                    a2.var_java_io_DataInputStream_a = new DataInputStream(new ByteArrayInputStream(a2.var_byte_arr_B));
                    for (n2 = 0; n2 < 4; ++n2) {
                        a2.var_boolean_arr_f[n2] = a2.var_java_io_DataInputStream_a.readBoolean();
                    }
                    n = a2.var_java_io_DataInputStream_a.readByte();
                    for (n2 = 0; n2 < n; ++n2) {
                        a2.var_int_arr_J[n2] = a2.var_java_io_DataInputStream_a.readInt();
                    }
                    a2.bW = a2.var_java_io_DataInputStream_a.readInt();
                    a2.bX = a2.var_java_io_DataInputStream_a.readInt();
                    a2.bY = a2.var_java_io_DataInputStream_a.readInt();
                }
                catch (Exception exception) {
                    a.void_a(string);
                    a2.var_boolean_arr_f[1] = true;
                    a2.z();
                }
                this.void_a(8);
                this.var_byte_n = 1;
                this.var_byte_o = (byte)2;
                this.var_boolean_D = false;
                return;
            }
            case 1: {
                this.var_boolean_C = false;
                this.void_d();
                if (this.ao < 51 && this.bY < this.ao) {
                    this.bY = this.ao;
                    this.z();
                }
                this.void_a(8);
                this.void_a(10);
                this.void_c();
                this.void_b(0);
                this.void_b(1);
                this.void_b(2);
                this.void_b(3);
                this.void_b(4);
                this.void_b(5);
                this.a((byte)2, -1);
                this.E();
                this.bL = -1;
                return;
            }
            case 14: {
                a a3 = this;
                this.var_int_t = 0;
                a3.var_int_u = 0;
                a3.var_int_v = 0;
                a3.var_java_lang_String_b = null;
                a3.var_java_lang_String_d = null;
                a3.var_javax_microedition_lcdui_Image_b = null;
                a3.var_boolean_d = false;
                return;
            }
            case 13: {
                return;
            }
            case 5: {
                this.w();
                this.var_byte_n = 0;
                this.var_byte_o = (byte)3;
                return;
            }
            case 4: {
                this.void_c();
                this.void_b(1);
                if (this.level > 50) {
                    this.void_b(17);
                }
                this.void_b(3);
                this.void_b(4);
                this.void_b(5);
                this.void_b(7);
                this.var_byte_n = 1;
                this.var_byte_o = (byte)3;
                return;
            }
            case 3: {
                this.var_boolean_C = true;
                this.var_byte_n = 1;
                this.var_byte_o = (byte)3;
                this.var_boolean_f = false;
                this.k();
                this.a((byte)3, -1);
                return;
            }
            case 7:
            case 8: {
                if (this.var_byte_b == 1) {
                    this.void_a(1);
                    this.void_a(8);
                    this.void_a(6);
                }
                this.var_byte_n = 1;
                this.var_byte_o = (byte)3;
                a a4 = this;
                a4.A();
                a4.bG = 208 / (a4.var_int_b + 4);
                if (a4.bG > 6) {
                    a4.bG = 6;
                }
                a4.bF = a4.var_int_a * 3 + 60;
                if (a4.bF < 148) {
                    a4.bF = 148;
                }
                a4.bB = 112 + (a4.var_int_b + 4) * a4.bG;
                a4.bE = 0;
                a4.bC = 0;
                a4.bD = a4.bG;
                return;
            }
            case 9: {
                return;
            }
            case 10: {
                a a5 = this;
                this.aT = 4;
                a5.aX = 32 / a5.aT;
                a5.aW = (268 - a5.var_int_b - 10) / 40;
                if (a5.aW > a5.aX) {
                    a5.aW = a5.aX;
                }
                a5.aU = 0;
                a5.aV = a5.aW;
                a5.aZ = 42 + 40 * a5.aT;
                a5.aY = 34 + a5.var_int_b + 10 + 40 * a5.aW;
                this.var_byte_n = 1;
                this.var_byte_o = (byte)3;
                return;
            }
            case 12: {
                a a6 = this;
                a6.i(0);
                this.var_byte_o = (byte)3;
                return;
            }
            case 19: {
                this.void_c();
                this.void_b(12);
                this.void_b(13);
                this.void_b(14);
                this.void_b(15);
                this.void_b(16);
                return;
            }
            case 15: {
                this.void_a(8);
                this.void_a(1);
                this.a((byte)0, "游戏描述：\n\\c99FFCC有人的地方就有江湖，有神仙的地方何尝不是江湖；百战百胜的本事，换不回女人的真心，兄弟的真义；齐天大圣又如何，没有真情实义，做神仙跟做咸鱼有什么区别？\n\n操作方式：按左软键调出物品栏，左右选择一件道具，按确定键使用。\n游戏操作：\n上方向键/2：向上行走\n下方向键/8：向下行走\n左方向键/4：向左行走\n右方向键/6：向右行走\n确定键/5:探索地图\n左软键：打开道具列表\n右软键：打开游戏中菜单\n\n代理发行：广州易诚计算机科技有限公司\n发行商网站：www.9266.net\n客服电话：4006509913\n客服信箱：kefu@9266.net", (byte)0, (byte)0);
                this.var_byte_n = 0;
                this.var_byte_o = (byte)3;
                return;
            }
            case 17: {
                this.void_a(8);
                this.void_a(1);
                this.a((byte)0, "版权所有：\n上海雪鲤鱼计算机科技有限公司\nwww.kgame.com.cn\n手机上网：\nwap.kgame.com.cn\n制作人：梁一\n编剧：王之浣\n策划：孙悦\n程序：杨政\n美术：梁一、王之浣、黄吉力\n测试：金鑫，王毅，计成毅\n版本：V1.0\n客服电话：4006305518", (byte)0, (byte)0);
                this.var_byte_n = 0;
                this.var_byte_o = (byte)3;
                return;
            }
            case 16: {
                this.void_a(8);
                this.void_a(1);
                this.aF = 0;
                this.void_h(0);
                this.void_h(1);
                this.var_byte_n = 0;
                this.var_byte_o = (byte)3;
                return;
            }
            case 20: {
                this.void_d();
                this.void_a(14);
                this.var_java_lang_String_d = this.var_java_lang_String_arr_o[260];
                this.var_int_H = 1;
                this.a(this.var_java_lang_String_c, 209, (this.var_int_I << 1) + 12, this.var_int_H);
                return;
            }
            case 22: {
                this.G();
            }
        }
    }

    protected final void showNotify() {
        if (this.var_boolean_b) {
            return;
        }
        this.var_boolean_b = true;
        super.showNotify();
    }

    protected final void hideNotify() {
        if (!this.var_boolean_b) {
            return;
        }
        if (this.gameStateFlag == 3) {
            this.gameStateFlag = (byte)4;
            this.void_a();
        }
        this.G();
        this.var_boolean_c = true;
        this.var_boolean_b = false;
        super.hideNotify();
    }

    private void void_a(int n) {
        int n2 = this.var_int_arr_a[n];
        int n3 = 0;
        if (this.gamePngImagesGroups[n] == null) {
            this.gamePngImagesGroups[n] = new Image[this.var_int_arr_a[n]];
        }
        this.var_java_io_InputStream_a = this.getClass().getResourceAsStream(this.var_java_lang_String_arr_b[n]);
        byte[] byArray = null;
        try {
            for (int i = 0; i < n2; ++i) {
                n3 = this.var_java_io_InputStream_a.read() & 0xFF | this.var_java_io_InputStream_a.read() << 8 & 0xFF00;
                if (this.gamePngImagesGroups[n][i] == null) {
                    if (byArray == null) {
                        byArray = new byte[n3];
                    } else if (byArray.length < n3) {
                        byArray = new byte[n3];
                    }
                    this.var_java_io_InputStream_a.read(byArray, 0, n3);
                    this.gamePngImagesGroups[n][i] = Image.createImage((byte[])byArray, (int)0, (int)n3);
                    continue;
                }
                this.var_java_io_InputStream_a.skip(n3);
            }
            return;
        }
        catch (Exception exception) {
            Exception exception2 = exception;
            exception.printStackTrace();
            return;
        }
        finally {
            this.void_b();
        }
    }

    private void a(Image image, int n, int n2, int n3, int n4, int n5, int n6) {
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n2, n5, n6);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n - n3, n2 - n4, 0);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    private static void a(Image image, Graphics graphics, int n, int n2, int n3, int n4, int n5, int n6) {
        graphics.setClip(n, n2, 5, 5);
        graphics.drawImage(image, n - n3, n2, 0);
        graphics.setClip(0, 0, 240, 320);
    }

    private void void_a(Image image, int n, int n2, int n3) {
        this.var_com_nokia_mid_ui_DirectGraphics_a.drawImage(image, n, n2, 0, var_int_arr_b[n3]);
    }

    private void a(Image image, int n, int n2, int n3, int n4, int n5, int n6, int n7) {
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n2, n5, n6);
        if (n7 == 0) {
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n - n3, n2 - n4, 0);
        } else {
            int n8 = image.getWidth();
            int n9 = image.getHeight();
            switch (n7) {
                case 1: {
                    this.void_a(image, n - (n8 - n3 - n5), n2 - n4, n7);
                    break;
                }
                case 2: {
                    this.void_a(image, n - n3, n2 - (n9 - n4 - n6), n7);
                    break;
                }
                case 3: {
                    this.void_a(image, n - (n8 - n3 - n5), n2 - (n9 - n4 - n6), n7);
                    break;
                }
                case 4: {
                    this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n2, n6, n5);
                    this.void_a(image, n - n4, n2 - n3, n7);
                    break;
                }
                case 5: {
                    this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n2, n6, n5);
                    this.void_a(image, n - (n9 - n4 - n6), n2 - n3, n7);
                    break;
                }
                case 6: {
                    this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n2, n6, n5);
                    this.void_a(image, n - n4, n2 - (n8 - n3 - n5), n7);
                    break;
                }
                case 7: {
                    this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n2, n6, n5);
                    this.void_a(image, n - (n9 - n4 - n6), n2 - (n8 - n3 - n5), n7);
                }
            }
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    private static Image javax_microedition_lcdui_Image_a(int n, int n2, int n3) {
        Object object = null;
        object = new int[1024];
        n2 = ((int[])object).length;
        while (--n2 >= 0) {
            object[n2] = n3;
        }
        Image image = Image.createRGBImage((int[])object, (int)32, (int)32, (boolean)true);
        object = image;
        return image;
    }

    private static Image a(Image image, int n) {
        int n2 = image.getWidth();
        int n3 = image.getHeight();
        int[] nArray = new int[n2 * n3];
        image.getRGB(nArray, 0, n2, 0, 0, n2, n3);
        n <<= 24;
        int n4 = n2 * n3;
        while (--n4 >= 0) {
            int n5 = nArray[n4];
            if (n5 == -1 || (n5 & 0xFF000000) == 0) continue;
            nArray[n4] = nArray[n4] & 0xFFFFFF | n;
        }
        return Image.createRGBImage((int[])nArray, (int)n2, (int)n3, (boolean)true);
    }

    private void void_b() {
        if (this.var_java_io_InputStream_a != null) {
            try {
                this.var_java_io_InputStream_a.close();
            }
            catch (Exception exception) {}
            this.var_java_io_InputStream_a = null;
        }
        if (this.var_java_io_OutputStream_a != null) {
            try {
                this.var_java_io_OutputStream_a.close();
            }
            catch (Exception exception) {}
            this.var_java_io_OutputStream_a = null;
        }
        if (this.var_java_io_InputStream_b != null) {
            try {
                this.var_java_io_InputStream_b.close();
            }
            catch (Exception exception) {}
            this.var_java_io_InputStream_b = null;
        }
    }

    protected final void keyPressed(int n) {
        this.var_int_f = this.pressedKeyCode = n;
        if (this.var_boolean_c) {
            if (this.gameStateFlag != 21 && this.gameStateFlag != 0) {
                if (!this.var_boolean_C) {
                    this.a((byte)2, -1);
                } else {
                    this.a((byte)3, -1);
                }
            }
            this.var_boolean_c = false;
        }
    }

    protected final void keyReleased(int n) {
        this.pressedKeyCode = 0;
    }

    private void void_c() {
        this.var_int_p = this.var_int_b + 6;
        this.var_int_n = 238 / this.var_int_p;
        this.var_int_o = this.var_int_p * this.var_int_n;
        this.var_int_i = this.var_int_a << 1;
        this.var_int_j = 0;
        this.var_int_h = 0;
        if (this.var_byte_arr_a == null) {
            this.var_byte_arr_a = new byte[16];
        }
        this.var_int_l = 0;
    }

    private void void_b(int n) {
        if (this.var_int_h < 16) {
            int n2 = this.var_javax_microedition_lcdui_Font_a.stringWidth(this.var_java_lang_String_arr_c[n]) + 60;
            this.var_byte_arr_a[this.var_int_h] = n;
            if (n2 > this.var_int_i) {
                this.var_int_i = n2;
            }
            ++this.var_int_h;
            if (this.var_int_h <= this.var_int_n) {
                this.var_int_m = this.var_int_h;
            }
            this.var_int_j += this.var_int_p;
            this.var_int_o = (this.var_int_m - this.var_int_l) * this.var_int_p;
        }
    }

    private void void_d() {
        this.gamePngImagesGroups[1] = null;
        this.gamePngImagesGroups[2] = null;
        this.gamePngImagesGroups[3] = null;
        this.gamePngImagesGroups[4] = null;
        this.gamePngImagesGroups[5] = null;
        this.gamePngImagesGroups[6] = null;
        this.gamePngImagesGroups[7] = null;
        this.gamePngImagesGroups[13] = null;
        this.gamePngImagesGroups[9] = null;
        this.gamePngImagesGroups[11] = null;
        this.gamePngImagesGroups[14] = null;
        this.gamePngImagesGroups[12] = null;
        this.actorSpriteImages = null;
    }

    private void void_e() {
        switch (this.var_byte_arr_a[this.var_int_k]) {
            case 0: {
                return;
            }
            case 1: {
                this.gameStateFlag = (byte)3;
                return;
            }
            case 2: {
                this.gameStateFlag = (byte)8;
                this.var_byte_b = (byte)4;
                this.void_a();
                return;
            }
            case 3: {
                this.gameStateFlag = (byte)7;
                this.var_byte_b = (byte)4;
                this.void_a();
                return;
            }
            case 4: {
                this.gameStateFlag = (byte)16;
                this.var_byte_b = (byte)4;
                this.void_a();
                return;
            }
            case 5: {
                this.gameStateFlag = (byte)15;
                this.var_byte_b = (byte)4;
                this.void_a();
                return;
            }
            case 7: {
                this.void_d();
                System.gc();
                try {
                    Thread.sleep(100L);
                }
                catch (Exception exception) {}
                this.gameStateFlag = 1;
                this.void_a();
                this.var_int_k = 0;
                return;
            }
            case 9: {
                return;
            }
            case 10: {
                return;
            }
            case 11: {
                this.gameStateFlag = (byte)19;
                this.void_a();
                return;
            }
            case 17: {
                this.a(1, false, false);
                this.gameStateFlag = (byte)3;
                this.playerHp = 1000;
                this.playerAttack = 710;
                this.playerAmaor = 710;
            }
        }
    }

    private void b(Image image, int n, int n2, int n3, int n4, int n5, int n6, int n7) {
        n = 86;
        n7 = this.var_byte_d;
        int n8 = 0;
        while (n8 < n5) {
            n3 = n + this.var_byte_arr_b[n7];
            n6 = n2 + this.var_byte_arr_c[n7];
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n3, n6, 17, 17);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n3 - n8, n6 - n4, 0);
            if (++n7 > 7) {
                n7 = 0;
            }
            n8 += 17;
            n += 17;
        }
        this.var_byte_d = (byte)(this.var_byte_d + 1);
        if (this.var_byte_d > 7) {
            this.var_byte_d = 0;
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    /*
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    private void void_f() {
        if (this.var_int_f == -7) {
            this.var_javax_microedition_lcdui_Image_b = null;
            this.gamePngImagesGroups[11] = null;
            this.gamePngImagesGroups[14] = null;
            this.var_java_lang_String_b = null;
            this.var_int_t = 0;
            this.var_int_u = 0;
            this.var_int_v = 0;
            this.u();
            return;
        }
        if (this.var_int_u == 0) {
            this.var_javax_microedition_lcdui_Image_b = null;
            switch (this.var_int_t) {
                case 0: {
                    this.void_a(11);
                    this.var_javax_microedition_lcdui_Image_b = a.a(this.gamePngImagesGroups[11][0], 34);
                    this.var_java_lang_String_b = this.var_java_lang_String_arr_a[4];
                    break;
                }
                case 1: {
                    this.void_a(11);
                    this.var_javax_microedition_lcdui_Image_b = a.a(this.gamePngImagesGroups[11][1], 34);
                    this.var_java_lang_String_b = this.var_java_lang_String_arr_a[6];
                    break;
                }
                case 2: {
                    this.gamePngImagesGroups[11] = null;
                    this.void_a(14);
                    this.var_javax_microedition_lcdui_Image_b = a.a(this.gamePngImagesGroups[14][0], 34);
                    this.var_java_lang_String_b = this.var_java_lang_String_arr_a[7];
                }
            }
            if (this.var_javax_microedition_lcdui_Image_b != null) {
                this.var_javax_microedition_lcdui_Image_b.getWidth();
            }
            this.var_boolean_d = false;
        }
        ++this.var_int_u;
        if (this.var_int_t < 3) {
            if (this.var_java_lang_String_d == null) return;
            if (!this.var_boolean_d) {
                if (this.var_int_v < this.var_javax_microedition_lcdui_Font_a.stringWidth(this.var_java_lang_String_arr_d[this.var_int_A]) + 10) {
                    this.var_int_v += 4;
                    if (this.var_int_f == 0) return;
                    this.var_int_v = 240;
                    return;
                }
                this.var_boolean_d = true;
                this.var_byte_e = 0;
                return;
            }
            this.var_byte_e = (byte)(this.var_byte_e + 1);
            if (this.var_byte_e < this.var_int_arr_c.length) return;
            this.var_int_v = 0;
            this.var_byte_e = 0;
            this.var_boolean_d = false;
            if (this.var_int_A < this.var_int_C - 2) {
                this.boolean_a(this.var_int_A + 2);
                return;
            }
            System.out.println("++~");
            ++this.var_int_t;
            this.var_int_u = 0;
            this.void_f();
            return;
        }
        this.var_javax_microedition_lcdui_Image_b = null;
        this.gamePngImagesGroups[11] = null;
        this.gamePngImagesGroups[14] = null;
        this.var_java_lang_String_b = null;
        this.var_int_t = 0;
        this.u();
    }

    private void a(byte by, String string, byte by2, byte by3) {
        this.var_boolean_f = true;
        this.var_byte_i = by;
        this.var_java_lang_String_c = string;
        switch (this.var_byte_i) {
            case 1:
            case 3: {
                this.a(string, 180, 234);
                this.var_int_y = 212;
                this.var_int_z = 68 + (this.var_int_B - this.var_int_A) * this.var_int_I;
                break;
            }
            case 0:
            case 2:
            case 4:
            case 5: {
                this.a(string, 180, 240);
                this.var_int_y = this.var_int_D + 32;
                this.var_int_z = 32 + (this.var_int_B - this.var_int_A) * this.var_int_I;
            }
        }
        this.var_byte_f = by2;
        this.var_byte_g = by3;
        if (by2 != 0 || by3 != 0) {
            this.var_int_z += 18;
        }
    }

    private void g() {
        switch (this.var_int_f) {
            case -1: {
                this.boolean_a(this.var_int_A - 1);
                return;
            }
            case -2: {
                this.boolean_a(this.var_int_A + 1);
                return;
            }
            case 0: {
                return;
            }
        }
        this.var_boolean_f = false;
    }

    private void a(String string, int n, int n2) {
        this.a(string, n, n2, string.length());
    }

    private void a(String string, int n, int n2, int n3) {
        char[] cArray = null;
        int n4 = 0;
        char c = '\u0000';
        int n5 = 0;
        int n6 = 0;
        int n7 = 0;
        int n8 = 0;
        if (string == null || string.length() == 0) {
            return;
        }
        cArray = string.toCharArray();
        for (int i = 0; i < n3; ++i) {
            c = cArray[i];
            n4 = this.var_javax_microedition_lcdui_Font_a.charWidth(c);
            if (c == '\n') {
                this.var_java_lang_String_arr_d[n6++] = new String(cArray, n7, n8);
                n7 = i + 1;
                n5 = 0;
                n8 = 0;
                continue;
            }
            if (c != '\\') {
                n4 = this.var_javax_microedition_lcdui_Font_a.charWidth(c);
            } else if (++i < n3) {
                c = string.charAt(i);
                if (c == 'c') {
                    if (i + 6 < n3 && a.int_a(string.substring(i + 1, i + 7)) != -1) {
                        i += 6;
                        n8 += 7;
                        n4 = 0;
                    } else {
                        n4 = this.var_javax_microedition_lcdui_Font_a.charWidth('\\') + this.var_javax_microedition_lcdui_Font_a.charWidth(c);
                    }
                } else if (c == 'r') {
                    ++n8;
                    n4 = 0;
                }
            } else {
                n4 = this.var_javax_microedition_lcdui_Font_a.charWidth('\\');
                --i;
            }
            if ((n5 += n4) > n) {
                this.var_java_lang_String_arr_d[n6++] = new String(cArray, n7, n8);
                n5 = n4;
                n7 = i;
                n8 = 1;
                continue;
            }
            ++n8;
        }
        if (n8 > 0) {
            this.var_java_lang_String_arr_d[n6++] = new String(cArray, n7, n8);
        }
        this.var_int_A = 0;
        this.var_int_C = n6;
        this.var_int_E = n2 / this.var_int_I;
        if (this.var_int_C < this.var_int_E) {
            this.var_int_E = this.var_int_C;
        }
        this.var_int_F = this.var_int_I * this.var_int_E;
        this.var_int_B = n6 > this.var_int_E ? this.var_int_E : n6;
        if (this.var_int_C == 1) {
            this.var_int_D = this.var_javax_microedition_lcdui_Font_a.stringWidth(string);
            return;
        }
        this.var_int_D = n;
    }

    private void a(String string, int n, int n2, int n3, int n4, boolean bl) {
        if (string == null) {
            return;
        }
        if (this.var_java_lang_String_d != string) {
            this.var_java_lang_String_d = string;
            this.a(string, n3, n4);
        }
        int n5 = n2 + 2;
        n4 = 0;
        n4 = 0;
        char c = '\u0000';
        this.var_int_G = this.var_javax_microedition_lcdui_Graphics_a.getColor();
        int n6 = this.var_int_A;
        while (--n6 >= 0) {
            if (this.var_java_lang_String_arr_d[n6] == null || (n4 = this.var_java_lang_String_arr_d[n6].lastIndexOf(92)) < 0 || (c = this.var_java_lang_String_arr_d[n6].charAt(n4 + 1)) != 'c') continue;
            n4 = a.int_a(this.var_java_lang_String_arr_d[n6].substring(n4 + 2, n4 + 8));
            this.var_javax_microedition_lcdui_Graphics_a.setColor(n4);
            break;
        }
        n6 = this.var_int_A;
        while (n6 < this.var_int_B) {
            int n7 = n5;
            int n8 = n;
            String string2 = this.var_java_lang_String_arr_d[n6];
            a a2 = this;
            int n9 = string2.length();
            int n10 = 0;
            int n11 = n8;
            char c2 = '\u0000';
            int n12 = 0;
            for (int i = 0; i < n9; ++i) {
                if (string2.charAt(i) != '\\') continue;
                if (i > 0) {
                    a2.var_javax_microedition_lcdui_Graphics_a.drawSubstring(string2, n10, i - n10, n11, n7, 0);
                    n11 += a2.var_javax_microedition_lcdui_Font_a.substringWidth(string2, n10, i - n10);
                }
                if (++i >= n9) continue;
                c2 = string2.charAt(i);
                if (c2 == 'c') {
                    if (i + 6 < n9) {
                        n12 = a.int_a(string2.substring(i + 1, i + 7));
                    }
                    if (n12 != -1) {
                        a2.var_int_G = a2.var_javax_microedition_lcdui_Graphics_a.getColor();
                        a2.var_javax_microedition_lcdui_Graphics_a.setColor(n12);
                        n10 = (i += 6) + 1;
                        continue;
                    }
                    n10 = i - 1;
                    continue;
                }
                if (c2 == 'r') {
                    a2.var_javax_microedition_lcdui_Graphics_a.setColor(a2.var_int_G);
                    n10 = i + 1;
                    continue;
                }
                n10 = i;
            }
            if (n10 != 0) {
                if (n10 < n9) {
                    a2.var_javax_microedition_lcdui_Graphics_a.drawSubstring(string2, n10, n9 - n10, n11, n7, 0);
                }
            } else {
                a2.var_javax_microedition_lcdui_Graphics_a.drawString(string2, n8, n7, 0);
            }
            ++n6;
            n5 += this.var_int_I;
        }
        n6 = n + (n3 >> 1);
        if (bl) {
            this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
            if (this.var_int_A > 0) {
                n5 = n2 - 8 + (this.var_int_d & 1);
                this.var_javax_microedition_lcdui_Graphics_a.fillTriangle(n6, n5, n6 - 7, n5 + 7, n6 + 7, n5 + 7);
            }
            if (this.var_int_B < this.var_int_C) {
                n5 = n2 + this.var_int_F + 3 - (this.var_int_d & 1);
                this.var_javax_microedition_lcdui_Graphics_a.fillTriangle(n6, n5, n6 - 6, n5 - 6, n6 + 6, n5 - 6);
            }
        }
    }

    private boolean boolean_a(int n) {
        if (n >= 0) {
            if (n >= this.var_int_C - this.var_int_E + 1) {
                n = this.var_int_C - this.var_int_E;
            }
        } else {
            n = 0;
        }
        this.var_int_A = n;
        this.var_int_B = this.var_int_A + this.var_int_E;
        if (this.var_int_A < 0) {
            this.var_int_A = 0;
        }
        if (this.var_int_B > this.var_int_C) {
            this.var_int_B = this.var_int_C;
        }
        return true;
    }

    private int int_a(int n) {
        int n2 = 0;
        int n3 = 0;
        int n4 = 0;
        if (this.var_java_lang_String_arr_d != null) {
            int n5 = 0;
            while (n5 < this.var_int_C) {
                n4 = this.var_java_lang_String_arr_d[n5].length();
                if (n >= n2 && n < (n3 += n4)) {
                    return n3;
                }
                ++n5;
                n2 += n4;
            }
        } else {
            n3 = 0;
        }
        return n3;
    }

    private static int int_a(String string) {
        int n = 0;
        try {
            n = Integer.parseInt(string, 16);
        }
        catch (Exception exception) {
            n = 0x2B2B2B;
            exception.printStackTrace();
        }
        return n;
    }

    private void updateHp(int n) {
        if (this.playerHp <= -n) {
            this.playerHp = 1;
            n = this.playerHp - 1;
        } else {
            this.playerHp += n;
        }
        if (n < 0) {
            this.a((byte)2, n, this.playerPixelX, this.playerPixelY);
            return;
        }
        if (n > 0) {
            if (this.var_byte_A > 0) {
                n <<= 4;
            }
            this.a((byte)3, n, this.playerPixelX, this.playerPixelY);
        }
    }

    private void void_a(int n, int n2) {
        this.playerXOffset = n;
        this.playerYOffest = n2;
        this.playerPixelX = n << 5;
        this.playerPixelY = n2 << 5;
        this.var_int_R = 0;
    }

    private void h() {
        if (this.var_int_M < this.var_int_arr_d.length - 1) {
            ++this.var_int_M;
            return;
        }
        this.var_int_M = 0;
    }

    private void i() {
        int n = 0;
        int n2 = 0;
        int n3 = 0;
        if (!this.var_boolean_g) {
            n = (this.preferWidth - 41 >> 1) - this.ae;
            n2 = (this.perferHeight >> 1) - this.af + this.var_int_U;
        } else {
            n = this.playerPixelX;
            n2 = this.playerPixelY;
        }
        if (this.var_int_arr_e[3] != n || this.var_int_arr_f[3] != n2) {
            this.var_int_arr_e[0] = n;
            this.var_int_arr_f[0] = n2;
            for (int i = 1; i < 4; ++i) {
                n3 = 4 - i;
                if (i == 0) {
                    n3 += 5;
                }
                if (this.var_int_arr_e[i] < n) {
                    int n4 = i;
                    this.var_int_arr_e[n4] = this.var_int_arr_e[n4] + ((n - this.var_int_arr_e[i] >> 1) + n3);
                    if (this.var_int_arr_e[i] > n) {
                        this.var_int_arr_e[i] = n;
                    }
                } else if (this.var_int_arr_e[i] > n) {
                    int n5 = i;
                    this.var_int_arr_e[n5] = this.var_int_arr_e[n5] + ((n - this.var_int_arr_e[i] >> 1) - n3);
                    if (this.var_int_arr_e[i] < n) {
                        this.var_int_arr_e[i] = n;
                    }
                }
                if (this.var_int_arr_f[i] < n2) {
                    int n6 = i;
                    this.var_int_arr_f[n6] = this.var_int_arr_f[n6] + ((n2 - this.var_int_arr_f[i] >> 1) + n3);
                    if (this.var_int_arr_f[i] > n2) {
                        this.var_int_arr_f[i] = n2;
                    }
                } else if (this.var_int_arr_f[i] > n2) {
                    int n7 = i;
                    this.var_int_arr_f[n7] = this.var_int_arr_f[n7] + ((n2 - this.var_int_arr_f[i] >> 1) - n3);
                    if (this.var_int_arr_f[i] < n2) {
                        this.var_int_arr_f[i] = n2;
                    }
                }
                n = this.var_int_arr_e[i];
                n2 = this.var_int_arr_f[i];
            }
            return;
        }
        if (this.var_boolean_g) {
            this.var_byte_l = 0;
        }
    }

    private void j() {
        int n = 0;
        if (this.gameStateFlag == 11) {
            this.l();
            return;
        }
        switch (this.var_int_f) {
            case -5:
            case 53: {
                a a2 = this;
                for (int i = 0; i < 4; ++i) {
                    a2.var_int_arr_e[i] = a2.var_int_N;
                    a2.var_int_arr_f[i] = a2.var_int_O;
                }
                a2.var_boolean_g = false;
                a a3 = a2;
                int n2 = 0;
                int n3 = a3.var_int_T;
                while (--n3 >= 0) {
                    n2 = a3.objectIdLookupTable[n3];
                    if (a3.var_boolean_arr_b[n3] || a3.var_byte_arr_d[n2] != 8) continue;
                    a3.var_int_arr_n[n2] = a3.int_a(n2, true);
                }
                a2.var_byte_l = (byte)2;
                a2.var_boolean_i = a2.int_c(13) >= 0;
                break;
            }
            case 49: {
                this.var_int_f = 0;
                if (!this.var_boolean_n || (n = this.int_a(true)) < 0) break;
                this.a(this.npcTalkIndexLookupTable[n] & 0xFF, false, true);
                break;
            }
            case 55: {
                this.var_int_f = 0;
                if (!this.var_boolean_n || (n = this.int_a(false)) < 0) break;
                this.a(this.npcTalkIndexLookupTable[n] & 0xFF, true, true);
            }
        }
        switch (this.pressedKeyCode) {
            case -1:
            case 50: {
                this.var_byte_m = 1;
                this.a(this.var_byte_m);
                return;
            }
            case -2:
            case 56: {
                this.var_byte_m = 0;
                this.a(this.var_byte_m);
                return;
            }
            case -3:
            case 52: {
                this.var_byte_m = (byte)3;
                this.a(this.var_byte_m);
                return;
            }
            case -4:
            case 54: {
                this.var_byte_m = (byte)2;
                this.a(this.var_byte_m);
            }
        }
    }

    /*
     * WARNING - void declaration
     */
    private boolean a(byte by) {
        void var2_6;
        boolean bl = false;
        int n = this.playerPixelX >> 5;
        int n2 = this.playerPixelY >> 5;
        switch (by) {
            case 1: {
                --n2;
                break;
            }
            case 0: {
                ++n2;
                break;
            }
            case 3: {
                void var2_4;
                --var2_4;
                break;
            }
            case 2: {
                void var2_5;
                ++var2_5;
            }
        }
        boolean bl2 = this.boolean_a((int)var2_6, n2);
        if (bl2) {
            this.var_byte_l = 1;
        } else if (this.var_boolean_f && this.var_byte_l == 1) {
            this.var_boolean_A = false;
            this.bS = 0;
            this.var_byte_l = 0;
        }
        return bl2;
    }

    /*
     * Enabled aggressive block sorting
     */
    private boolean boolean_a(int n, int n2) {
        byte by = 0;
        int n3 = 0;
        int n4 = 0;
        n4 = 0;
        int talkIndex = 1;
        int n6 = 0;
        by = this.var_byte_arr_arr_c[n2][n];
        if (this.var_byte_arr_k[by] <= 0) {
            if (this.boolean_b(n, n2)) return talkIndex != 0;
            return 0 != 0;
        }
        int n7 = this.var_byte_arr_k[by];
        while (true) {
            if (--n7 < 0) {
                if (talkIndex == 0) return talkIndex != 0;
                if (n6 > 0) return talkIndex != 0;
                return this.boolean_b(n, n2) != 0;
            }
            n3 = this.var_byte_arr_arr_d[by][n7] - 1;
            n4 = this.objectIdLookupTable[n3];
            if (this.var_byte_arr_e[n3] == 1) continue;
            block0 : switch (this.objectTypeLookupTable[n4]) {
                case 8: {       //怪物
                    n4 = this.caculateHpReduce(n4, true);
                    talkIndex = 0;
                    if (n4 < 0 || n4 >= this.playerHp) {
                        this.bS = 0;
                        this.a((byte)0, "你无法战胜它", (byte)0, (byte)0);
                        break;
                    }
                    n4 = n3;
                    this.var_byte_l = (byte)5;
                    this.var_byte_arr_e[n4] = 3;
                    this.var_int_S = n4;
                    this.bU = this.monsterHpBaseArray[this.objectIdLookupTable[n4] - 41];
                    this.var_boolean_o = true;
                    this.var_boolean_z = true;
                    break;
                }
                case 32: {
                    talkIndex = 0;
                    break;
                }
                case 16: {          //商人
                    n4 = n3;
                    this.currentBussinessManId = n4;
                    talkIndex = this.npcTalkIndexLookupTable[n4];
                    byte by2 = (byte)(talkIndex >>> 8);
                    talkIndex = (byte)talkIndex;
                    int n8 = n4 = this.objectIdLookupTable[n4] == 77 ? 0 : 1;
                    if (talkIndex > 0) {
                        talkIndex = (byte)(talkIndex - 1);
                        if ((by2 & 2) != 0) {
                            switch (n4) {
                                case 0: {                   //太白金星
                                    boolean bl = false;
                                    n4 = talkIndex;
                                    this.a((byte)4, this.var_java_lang_String_arr_h[n4], (byte)0, (byte)0);
                                    break;
                                }
                                case 1: {                   //其他NPC
                                    this.a((byte)4, this.var_java_lang_String_arr_i[talkIndex], (byte)1, (byte)2);
                                }
                            }
                        } else {
                            this.j(n4, talkIndex);
                            switch (n4) {
                                case 0: {
                                    this.a((byte)4, this.var_java_lang_String_arr_g[talkIndex], (byte)0, (byte)0);
                                    break;
                                }
                                case 1: {
                                    this.a((byte)4, this.var_java_lang_String_arr_j[talkIndex], (byte)1, (byte)2);
                                    break;
                                }
                            }
                        }
                    }
                    talkIndex = 0;
                    break;
                }
                case 1: {
                    switch (n4) {
                        case 7:
                        case 8: {
                            n6 = (byte)(n6 + 1);
                            break block0;
                        }
                        case 83: {
                            if (!this.b((int)this.npcTalkIndexLookupTable[n3], false)) break;
                            this.var_boolean_f = false;
                            this.var_java_lang_String_c = null;
                            talkIndex = this.boolean_d(this.npcTalkIndexLookupTable[n3]) ? 1 : 0;
                            n7 = 0;
                            break block0;
                        }
                        case 1: {
                            talkIndex = this.hasKey((byte)26);
                            if (talkIndex != 0) {
                                this.void_e(n3);
                                break block0;
                            }
                            this.bS = 0;
                            this.a((byte)0, "你没有黄钥匙", (byte)0, (byte)0);
                            break block0;
                        }
                        case 3: {
                            talkIndex = this.hasKey((byte)28);
                            if (talkIndex != 0) {
                                this.void_e(n3);
                                break block0;
                            }
                            this.bS = 0;
                            this.a((byte)0, "你没有蓝钥匙", (byte)0, (byte)0);
                            break block0;
                        }
                        case 2: {
                            talkIndex = this.hasKey((byte)27);
                            if (talkIndex != 0) {
                                this.void_e(n3);
                                break block0;
                            }
                            this.bS = 0;
                            this.a((byte)0, "你没有红钥匙", (byte)0, (byte)0);
                            break block0;
                        }
                        case 81: {
                            if (!this.spritePassable[n3]) break;
                            this.a((byte)0, "障碍物：封印门\n需要消灭指定的怪物才能打开的门！", (byte)0, (byte)0);
                            talkIndex = 0;
                            n7 = 0;
                            break block0;
                        }
                        case 4: {
                            this.a((byte)0, "障碍物：封印门\n需要消灭指定的怪物才能打开的门！", (byte)0, (byte)0);
                            talkIndex = 0;
                            n7 = 0;
                            break block0;
                        }
                        case 9: {
                            talkIndex = 0;
                            if (this.var_byte_m != 1) break;
                            n7 = 0;
                            this.gameStateFlag = (byte)9;
                            a a4 = this;
                            n4 = a4.level;
                            a4.ay = a.int_b(a4.ar + 1);
                            a4.az = a.int_a(100, n4);
                            a4.aA = a.int_a(2, n4);
                            a4.aB = a.int_a(4, n4);
                            this.void_a();
                            break block0;
                        }
                        case 10: {
                            this.a((byte)0, "障碍物：三昧真火\n必须用芭蕉扇才能熄灭它. ", (byte)0, (byte)0);
                            talkIndex = 0;
                            n7 = 0;
                            break block0;
                        }
                        case 11: {
                            if (this.level != 23) {
                                this.a((byte)0, "障碍物：墙\n只有金勺子、玄明石可以凿开。或者剧情打开！", (byte)0, (byte)0);
                            }
                            talkIndex = 0;
                            n7 = 0;
                            break block0;
                        }
                        case 12: {
                            this.objectIdLookupTable[n3] = 11;
                            this.initSpriteWidthHeight(11, n3);
                            this.initSpriteProperty(11, n3);
                            this.var_byte_arr_e[n3] = 2;
                            this.var_int_arr_m[n3] = 9;
                            this.spritePassable[n3] = true;
                            talkIndex = 0;
                            break block0;
                        }
                        case 6: {
                            n6 = (byte)(n6 + 1);
                            if (this.spritePassable[n3]) break;
                            this.spritePassable[n3] = true;
                            this.var_byte_arr_e[n3] = 2;
                            this.var_int_arr_m[n3] = 9;
                        }
                    }
                    break;
                }
            }
        }
    }

    /*
     * Unable to fully structure code
     */
    private void k() {
        block62: {
            block61: {
                block59: {
                    var1_1 = false;
                    this.playerXOffset = this.playerPixelX >> 5;
                    this.playerYOffest = this.playerPixelY >> 5;
                    var1_1 = false;
                    var2_6 = 0;
                    var3_7 = this.var_byte_arr_arr_c[this.playerYOffest][this.playerXOffset];
                    this.var_boolean_h = false;
                    var1_2 = this;
                    var2_6 = 0;
                    var6_8 = 0;
                    var7_9 = var1_2.var_byte_k == 40 ? 1 : 0;
                    if (var7_9 == 0) {
                        var10_10 = var1_2.var_int_Q;
                        var9_11 = var1_2.var_int_P;
                        var8_13 = var1_2;
                        if (var9_11 > 0 && var8_13.int_b(var9_11 - 1, var10_10, 61) >= 0 && var9_11 < var8_13.Y - 1 && var8_13.int_b(var9_11 + 1, var10_10, 61) >= 0 ? true : var10_10 > 0 && var8_13.int_b(var9_11, var10_10 - 1, 61) >= 0 && var10_10 < var8_13.Z - 1 && var8_13.int_b(var9_11, var10_10 + 1, 61) >= 0) {
                            var1_2.void_c(-(var1_2.var_int_J >> 1));
                        }
                        var11_16 = 62;
                        var10_10 = var1_2.var_int_Q;
                        var9_11 = var1_2.var_int_P;
                        var8_13 = var1_2;
                        var12_17 = 0;
                        if (var9_11 > 0 && var8_13.int_b(var9_11 - 1, var10_10, 62) >= 0) {
                            ++var12_17;
                        }
                        if (var9_11 < var8_13.Z - 1 && var8_13.int_b(var9_11 + 1, var10_10, 62) >= 0) {
                            ++var12_17;
                        }
                        if (var10_10 > 0 && var8_13.int_b(var9_11, var10_10 - 1, 62) >= 0) {
                            ++var12_17;
                        }
                        if (var10_10 < var8_13.Z - 1 && var8_13.int_b(var9_11, var10_10 + 1, 62) >= 0) {
                            ++var12_17;
                        }
                        if ((var2_6 = var12_17) > 0) {
                            var1_2.void_c(-100);
                        }
                    }
                    var11_16 = var7_9;
                    var10_10 = var1_2.var_int_Q;
                    var9_11 = var1_2.var_int_P;
                    var8_13 = var1_2;
                    var12_17 = 0;
                    var7_9 = 0;
                    if (var11_16 == 0) {
                        var7_9 = var8_13.int_b(var9_11 - 1, var10_10, 60);
                        if (var9_11 > 0 && var7_9 >= 0) {
                            ++var12_17;
                        }
                        var7_9 = var8_13.int_b(var9_11 + 1, var10_10, 60);
                        if (var9_11 < var8_13.Z - 1 && var7_9 >= 0) {
                            ++var12_17;
                        }
                        var7_9 = var8_13.int_b(var9_11, var10_10 - 1, 60);
                        if (var10_10 > 0 && var7_9 >= 0) {
                            ++var12_17;
                            var8_13.d(var9_11, var10_10 - 1, var7_9);
                        }
                        var7_9 = var8_13.int_b(var9_11, var10_10 + 1, 60);
                        if (var10_10 < var8_13.Z - 1 && var7_9 >= 0) {
                            ++var12_17;
                        }
                    } else {
                        var7_9 = var8_13.int_b(var9_11, var10_10 - 1, 60);
                        if (var10_10 > 0 && var7_9 >= 0) {
                            var8_13.d(var9_11, var10_10 - 1, var7_9);
                        }
                    }
                    if ((var2_6 = var12_17) > 0) {
                        var1_2.void_c(-200);
                        var6_8 = 1;
                    }
                    var4_18 = var6_8;
                    if (this.var_byte_arr_k[var3_7] <= 0) break block59;
                    var5_19 = this.var_byte_arr_k[var3_7];
                    while (--var5_19 >= 0) {
                        block60: {
                            var1_3 = this.var_byte_arr_arr_d[var3_7][var5_19] - 1;
                            var2_6 = this.objectIdLookupTable[var1_3];
                            switch (this.objectTypeLookupTable[var2_6]) {
                                case 2:
                                case 4: {
                                    this.pickupGroundItem(var2_6);
                                    this.void_e(var1_3);
                                    break;
                                }
                                case 1: {
                                    switch (var2_6) {
                                        case 83: {
                                            if (this.b((int)this.npcTalkIndexLookupTable[var1_3], true)) {
                                                this.var_boolean_f = false;
                                                this.boolean_d(this.npcTalkIndexLookupTable[var1_3]);
                                                var4_18 = 1;
                                                var5_19 = 0;
                                            }
                                            break block60;
                                        }
                                        case 7: {
                                            var1_3 = this.npcTalkIndexLookupTable[var1_3] & 255;
                                            this.a(var1_3, false, false);
                                            this.pressedKeyCode = 0;
                                            var5_19 = 0;
                                            break block60;
                                        }
                                        case 8: {
                                            var1_3 = this.npcTalkIndexLookupTable[var1_3] & 255;
                                            this.a(var1_3, true, false);
                                            this.pressedKeyCode = 0;
                                            var5_19 = 0;
                                            break block60;
                                        }
                                        case 5: {
                                            var1_3 = this.npcTalkIndexLookupTable[var1_3];
                                            this.void_b(this.playerXOffset, this.playerYOffest, var5_19);
                                            if (this.boolean_b(var1_3)) {
                                                this.var_byte_l = (byte)4;
                                            }
                                            break block60;
                                        }
                                        case 76: {
                                            var1_3 = (this.npcTalkIndexLookupTable[var1_3] & 255) + 1;
                                            this.void_b(this.playerXOffset, this.playerYOffest, var5_19);
                                            var2_6 = var1_3;
                                            var1_4 = this;
                                            var6_8 = 0;
                                            var1_4.aI = 0;
                                            var7_9 = 0;
                                            for (var8_14 = 0; var8_14 < var1_4.var_int_T; ++var8_14) {
                                                if (var1_4.var_boolean_arr_b[var8_14]) continue;
                                                var7_9 = var1_4.var_short_arr_a[var8_14] & 255;
                                                var6_8 = var1_4.objectIdLookupTable[var8_14];
                                                if (var6_8 == 76) {
                                                    if (var7_9 + 1 != var2_6) continue;
                                                    var11_16 = var1_4.var_int_arr_h[var8_14] >> 5;
                                                    var10_10 = var1_4.var_int_arr_g[var8_14] >> 5;
                                                    var9_12 = var1_4;
                                                    var12_17 = var9_12.var_byte_arr_arr_c[var11_16][var10_10];
                                                    var7_9 = var9_12.var_byte_arr_k[var12_17];
                                                    if (var9_12.var_byte_arr_k[var12_17] <= 0) continue;
                                                    var6_8 = var7_9;
                                                    while (--var6_8 >= 0) {
                                                        var9_12.var_boolean_arr_b[var9_12.var_byte_arr_arr_d[var12_17][var6_8] - 1] = true;
                                                    }
                                                    var9_12.var_byte_arr_k[var12_17] = 0;
                                                    continue;
                                                }
                                                if (var6_8 != 4 || var7_9 != var2_6) continue;
                                                var1_4.var_short_arr_d[var1_4.aI] = var8_14;
                                                var1_4.var_short_arr_b[var1_4.aI] = var1_4.var_int_arr_g[var8_14] >> 5;
                                                var1_4.var_short_arr_c[var1_4.aI] = var1_4.var_int_arr_h[var8_14] >> 5;
                                                ++var1_4.aI;
                                            }
                                            if (var1_4.aI > 0) {
                                                this.var_byte_l = (byte)4;
                                            }
                                            break block60;
                                        }
                                        case 6: {
                                            this.var_boolean_h = true;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (this.var_byte_l != 4) {
                        this.var_byte_l = 0;
                        if (var4_18 == 0) {
                            this.j();
                        }
                    }
                    break block61;
                }
                if (this.var_boolean_B) {
                    if (var4_18 == 0) {
                        this.l();
                    } else {
                        this.var_byte_l = 0;
                    }
                } else {
                    this.var_byte_l = 0;
                    if (var4_18 == 0) {
                        this.j();
                    }
                }
            }
            if (!this.var_boolean_A) break block62;
            if (this.bS <= 0) ** GOTO lbl163
            if (this.var_byte_arr_Q[this.bS - 1] == this.var_byte_m) {
                --this.bS;
            } else {
                this.bS = 0;
                lbl163:
                // 2 sources

                this.var_boolean_A = false;
            }
        }
        var1_5 = this;
        var2_6 = var1_5.var_int_P;
        var6_8 = var1_5.var_int_Q;
        var7_9 = var1_5.as >> 5;
        var8_15 = var1_5.au >> 5;
        var9_11 = var1_5.at >> 5;
        var10_10 = var1_5.av >> 5;
        var1_5.var_boolean_n = false;
        if (var1_5.var_boolean_m) {
            if (var6_8 > 0) {
                if (var2_6 == var7_9 && var6_8 - 1 == var8_15) {
                    var1_5.var_boolean_n = true;
                } else if (var2_6 == var9_11 && var6_8 - 1 == var10_10) {
                    var1_5.var_boolean_n = true;
                }
            }
            if (var6_8 < var1_5.Z - 1) {
                if (var2_6 == var7_9 && var6_8 + 1 == var8_15) {
                    var1_5.var_boolean_n = true;
                } else if (var2_6 == var9_11 && var6_8 + 1 == var10_10) {
                    var1_5.var_boolean_n = true;
                }
            }
            if (var2_6 > 0) {
                if (var2_6 - 1 == var7_9 && var6_8 == var8_15) {
                    var1_5.var_boolean_n = true;
                } else if (var2_6 - 1 == var9_11 && var6_8 == var10_10) {
                    var1_5.var_boolean_n = true;
                }
            }
            if (var2_6 < var1_5.Y - 1) {
                if (var2_6 + 1 == var7_9 && var6_8 == var8_15) {
                    var1_5.var_boolean_n = true;
                    return;
                }
                if (var2_6 + 1 == var9_11 && var6_8 == var10_10) {
                    var1_5.var_boolean_n = true;
                }
            }
        }
    }

    private void void_b(int n, int n2) {
        if (this.boolean_b(n, n2 - 1)) {
            --n2;
        } else if (this.boolean_b(n, n2 + 1)) {
            ++n2;
        } else if (this.boolean_b(n - 1, n2)) {
            --n;
        } else if (this.boolean_b(n + 1, n2)) {
            ++n;
        }
        this.void_a(n, n2);
        this.i((this.preferWidth - 32 >> 1) - this.playerPixelX, (this.perferHeight - 32 >> 1) - this.playerPixelY);
    }

    private void l() {
        if (this.bS > 0) {
            this.var_byte_m = this.var_byte_arr_Q[--this.bS];
            boolean bl = this.a(this.var_byte_m);
            if (this.bS == 0) {
                this.var_boolean_B = false;
                return;
            }
            if (!bl) {
                this.var_boolean_B = false;
                if (this.var_byte_l != 5) {
                    this.var_byte_l = 0;
                    this.bS = 0;
                }
            }
        }
    }

    private void void_c(int n, int n2) {
        int n3 = n + this.playerPixelX;
        int n4 = n2 + this.playerPixelY;
        int n5 = 0;
        if (this.var_boolean_h) {
            n4 -= this.var_int_U;
        }
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[5][0], n3 + 8, n4 + 22, 0);
        switch (this.var_byte_m) {
            case 1: {
                this.a(this.gamePngImagesGroups[3][0], n3 - 8, n4 - 14, this.var_int_arr_d[this.var_int_M] * 41, 46, 41, 46);
                if (this.var_byte_l != 2) break;
                n5 = 4;
                while (--n5 >= 0) {
                    this.a(this.var_javax_microedition_lcdui_Image_c, n + this.var_int_arr_e[n5] - 8, n2 + this.var_int_arr_f[n5] - 14, this.var_int_arr_d[this.var_int_M] * 41, 46, 41, 46);
                }
                break;
            }
            case 0: {
                if (this.var_byte_l == 2) {
                    n5 = 4;
                    while (--n5 >= 0) {
                        this.a(this.var_javax_microedition_lcdui_Image_c, n + this.var_int_arr_e[n5] - 4, n2 + this.var_int_arr_f[n5] - 14, this.var_int_arr_d[this.var_int_M] * 41, 0, 41, 46);
                    }
                }
                this.a(this.gamePngImagesGroups[3][0], n3 - 3, n4 - 18, this.var_int_arr_d[this.var_int_M] * 41, 0, 41, 46);
                break;
            }
            case 3: {
                if (this.var_byte_l == 2) {
                    n5 = 4;
                    while (--n5 >= 0) {
                        this.a(this.var_javax_microedition_lcdui_Image_c, n + this.var_int_arr_e[n5], n2 + this.var_int_arr_f[n5] - 14, this.var_int_arr_d[this.var_int_M] * 41, 92, 41, 46, 1);
                    }
                }
                this.a(this.gamePngImagesGroups[3][0], n3, n4 - 16, this.var_int_arr_d[this.var_int_M] * 41, 92, 41, 46, 1);
                break;
            }
            case 2: {
                if (this.var_byte_l == 2) {
                    n5 = 4;
                    while (--n5 >= 0) {
                        this.a(this.var_javax_microedition_lcdui_Image_c, n + this.var_int_arr_e[n5] - 6, n2 + this.var_int_arr_f[n5] - 14, this.var_int_arr_d[this.var_int_M] * 41, 92, 41, 46);
                    }
                }
                this.a(this.gamePngImagesGroups[3][0], n3 - 8, n4 - 16, this.var_int_arr_d[this.var_int_M] * 41, 92, 41, 46);
            }
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        if (this.var_boolean_A) {
            n3 = (this.playerXOffset << 5) + n;
            n4 = (this.playerYOffest << 5) + n2;
            n5 = this.bS;
            while (--n5 >= 0) {
                this.var_javax_microedition_lcdui_Graphics_a.setColor(136);
                switch (this.var_byte_arr_Q[n5]) {
                    case 1: {
                        this.a(this.gamePngImagesGroups[8][22], n3 + 5, (n4 -= 32) + 5 + this.var_int_U, 0, 0, 21, 22);
                        break;
                    }
                    case 0: {
                        this.a(this.gamePngImagesGroups[8][22], n3 + 5, (n4 += 32) + 5 + this.var_int_U, 21, 0, 21, 22);
                        break;
                    }
                    case 3: {
                        this.a(this.gamePngImagesGroups[8][22], (n3 -= 32) + 5 + this.var_int_U, n4 + 5, 42, 0, 21, 22);
                        break;
                    }
                    case 2: {
                        this.a(this.gamePngImagesGroups[8][22], (n3 += 32) + 5 + this.var_int_U, n4 + 5, 42, 0, 21, 22, 1);
                    }
                }
            }
        }
        n3 = n + this.playerPixelX;
        n4 = n2 + this.playerPixelY;
        switch (this.var_byte_l) {
            case 2: {
                n5 = this.var_int_U;
                this.a(this.gamePngImagesGroups[8][23], 5 - n5, 148, 44, 0, 22, 24);
                this.a(this.gamePngImagesGroups[8][23], 109, 25 - n5, 0, 0, 22, 24);
                this.a(this.gamePngImagesGroups[8][23], 109, this.var_int_W - 29 + n5, 22, 0, 22, 24);
                this.a(this.gamePngImagesGroups[8][23], 215 + n5, 148, 44, 0, 22, 24, 1);
                return;
            }
            case 3: {
                n2 = n4 - 40;
                n = n3 + 16;
                n3 = 0;
                n4 = 0;
                if (this.aS < this.bagItemCount) {
                    n3 = this.playerBagArray[this.aS];
                    this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.actorSpriteImages[n3], n - 16, n2 + 4, 0);
                    if (this.aS > 0) {
                        this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                        this.a(n - 18 - (this.var_int_d & 1), n2 + 16, (byte)3);
                    }
                    if (this.aS < this.bagItemCount - 1) {
                        this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                        this.a(n + 18 + (this.var_int_d & 1), n2 + 16, (byte)3);
                    }
                    this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                    n4 = this.var_javax_microedition_lcdui_Font_a.stringWidth(this.var_java_lang_String_arr_m[n3]);
                    this.var_javax_microedition_lcdui_Graphics_a.fillRect((n -= n4 >> 1) - 5, n2 -= this.var_int_b + 4, n4 + 10, this.var_int_b + 4);
                    this.var_javax_microedition_lcdui_Graphics_a.setColor(0);
                    this.var_javax_microedition_lcdui_Graphics_a.drawString(this.var_java_lang_String_arr_m[n3], n, n2 + 2, 0);
                    return;
                }
                this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                this.var_javax_microedition_lcdui_Graphics_a.fillRect((n -= this.var_int_a >> 1) - 5, n2 -= this.var_int_b + 4 - 32, this.var_int_a + 10, this.var_int_b + 4);
                this.var_javax_microedition_lcdui_Graphics_a.setColor(0);
                this.var_javax_microedition_lcdui_Graphics_a.drawString("无", n, n2 + 2, 0);
            }
        }
    }

    private void m() {
        if (this.var_byte_n != 0) {
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][10], 0, 302, 0);
            this.a(this.gamePngImagesGroups[8][11], 2, 307, (this.var_byte_n - 1) * 12, 0, 12, 10);
        }
        if (this.var_byte_o != 0) {
            this.void_a(this.gamePngImagesGroups[8][10], 222, 302, 1);
            this.a(this.gamePngImagesGroups[8][11], 226, 307, (this.var_byte_o - 1) * 12, 0, 12, 10);
        }
    }

    private void void_d(int n, int n2) {
        n = n2;
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][3], 0, n, 0);
        if (this.level > 50) {
            this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
            this.a("引子", 32, n + 9 + (19 - this.var_int_b >> 1), 17, this.var_int_arr_K);
            n += 4;
        } else {
            this.int_a(this.gamePngImagesGroups[8][18], this.level, 40, (n += 4) + 2);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][8], 41, n + 10, 0);
        }
        this.var_javax_microedition_lcdui_Graphics_a.setColor(2435368);
        this.var_javax_microedition_lcdui_Graphics_a.fillRect(65, n2, 175, 18);
        this.void_a(0, this.yellowKeyCount, 65, n -= 4);
        this.void_a(1, this.blueKeyCount, 107, n);
        this.void_a(2, this.redKeyCount, 149, n);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][1], 191, n += 3, 0);
        this.int_a(this.gamePngImagesGroups[8][2], this.aQ, 237, n + 2);
    }

    private void void_a(int n, int n2, int n3, int n4) {
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n3, n4, 18, 16);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][6], n3 - n * 18, n4, 0);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        this.int_a(this.gamePngImagesGroups[8][2], n2, n3 += 40, n4 += 5);
    }

    private void e(int n, int n2) {
        this.b(0, n2, 240, 50);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[3][1], 40 - (this.gamePngImagesGroups[3][1].getWidth() >> 1), n2 + 50 - this.gamePngImagesGroups[3][1].getHeight(), 0);
        int n3 = n = 83;
        int n4 = n2 += 13;
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n3, n4, 10, 10);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][7], n3, n4 - 2, 0);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        this.d(n3 += 16, n4 + 1, 58, 11);
        this.int_a(this.gamePngImagesGroups[8][2], this.playerHp, n3 + 52, n4 + 2);
        n3 = n;
        this.a(this.gamePngImagesGroups[8][7], n3, n4 += 12, 10, 0, 10, 13);
        this.var_javax_microedition_lcdui_Graphics_a.setColor(512);
        this.d(n3 += 16, n4 + 1, 58, 11);
        this.int_a(this.gamePngImagesGroups[8][2], this.playerAttack, n3 + 52, n4 + 2);
        n3 = n;
        this.a(this.gamePngImagesGroups[8][7], n3, n4 += 12, 20, 0, 10, 13);
        this.var_javax_microedition_lcdui_Graphics_a.setColor(512);
        this.d(n3 += 16, n4 + 1, 58, 11);
        this.int_a(this.gamePngImagesGroups[8][2], this.playerAmaor, n3 + 52, n4 + 2);
        n4 = n2 + 2;
        this.d(n3 += 60, n4, 32, 32);
        if (this.playerWeapon == 0) {
            this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
            this.var_javax_microedition_lcdui_Graphics_a.drawString(this.var_java_lang_String_arr_e[this.playerWeapon], n3 + (32 - this.var_int_a >> 1), n4 + (32 - this.var_int_b >> 1), 0);
        } else {
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.actorSpriteImages[this.playerWeapon], n3 + (32 - this.actorSpriteImages[this.playerWeapon].getWidth() >> 1), n4 + (32 - this.actorSpriteImages[this.playerWeapon].getHeight() >> 1), 0);
        }
        this.d(n3 += 34, n4, 32, 32);
        if (this.playerCloth == 0) {
            this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
            this.var_javax_microedition_lcdui_Graphics_a.drawString(this.var_java_lang_String_arr_e[this.playerCloth], n3 + (32 - this.var_int_a >> 1), n4 + (32 - this.var_int_b >> 1), 0);
            return;
        }
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.actorSpriteImages[this.playerCloth], n3 + (32 - this.actorSpriteImages[this.playerCloth].getWidth() >> 1), n4 + (32 - this.actorSpriteImages[this.playerCloth].getHeight() >> 1), 0);
    }

    private void a(int n, int n2, int n3, int n4, int n5) {
        this.c(n2, n3, n4, n5);
        n3 -= 2;
        n2 += 2;
        int[] nArray = this.var_int_arr_arr_a[n];
        n4 = nArray.length;
        n5 = 0;
        while (n5 < n4) {
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n2, n3, 14, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][13], n2 - nArray[n5] * 14, n3, 0);
            ++n5;
            n2 += 14;
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    private void b(int n, int n2, int n3, int n4) {
        int n5 = n;
        int n6 = n2;
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n5, n6, 26, 16);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n5, n6, 0);
        n5 += 26;
        while (n5 < n + n3 - 26) {
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n5, n6, 16, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n5 - 26, n6, 0);
            n5 += 16;
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        this.a(this.gamePngImagesGroups[8][0], n + n3 - 26, n6, 0, 0, 26, 16, 1);
        n5 = n + 11;
        this.var_javax_microedition_lcdui_Graphics_a.setColor(2699825);
        this.var_javax_microedition_lcdui_Graphics_a.fillRect(n5, n6 += 16, n3 - 22, n4 - 16);
        n5 = n + n3 - 11;
        while (n6 < n2 + n4) {
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n6, 11, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n - 42, n6, 0);
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n5, n6, 11, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n5 - 53, n6, 0);
            n6 += 16;
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    private void c(int n, int n2, int n3, int n4) {
        int n5 = n;
        int n6 = n2;
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n5, n6, 26, 16);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n5, n6, 0);
        n5 += 26;
        while (n5 < n + n3 - 26) {
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n5, n6, 16, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n5 - 26, n6, 0);
            this.a(this.gamePngImagesGroups[8][0], n5, n6 + n4 - 16, 26, 0, 16, 16, 2);
            n5 += 16;
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        this.a(this.gamePngImagesGroups[8][0], n + n3 - 26, n6, 0, 0, 26, 16, 1);
        n5 = n + 11;
        this.var_javax_microedition_lcdui_Graphics_a.setColor(2699825);
        this.var_javax_microedition_lcdui_Graphics_a.fillRect(n5, n6 += 16, n3 - 22, n4 - 32);
        n5 = n + n3 - 11;
        while (n6 < n2 + n4 - 16) {
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n, n6, 11, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n - 42, n6, 0);
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n5, n6, 11, 16);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][0], n5 - 53, n6, 0);
            n6 += 16;
        }
        n6 = n2 + n4 - 16;
        this.a(this.gamePngImagesGroups[8][0], n, n6, 0, 0, 26, 16, 2);
        this.a(this.gamePngImagesGroups[8][0], n + n3 - 26, n6, 0, 0, 26, 16, 3);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    private void d(int n, int n2, int n3, int n4) {
        int n5 = n2 + n4 - 2;
        int n6 = n + n3 - 1;
        this.var_javax_microedition_lcdui_Graphics_a.setColor(4803902);
        this.var_javax_microedition_lcdui_Graphics_a.fillRect(n + 1, n2, n3 - 2, n4 - 1);
        this.var_javax_microedition_lcdui_Graphics_a.drawLine(n, n2 + 1, n, n5);
        this.var_javax_microedition_lcdui_Graphics_a.setColor(1645850);
        this.var_javax_microedition_lcdui_Graphics_a.drawLine(n6, n2 + 1, n6, n5);
        this.var_javax_microedition_lcdui_Graphics_a.drawLine(n + 1, n5 + 1, n6 - 1, n5 + 1);
    }

    private int int_a(Image image, int n, int n2, int n3) {
        boolean bl = n < 0;
        if (bl) {
            n = -n;
        }
        int n4 = image.getWidth() / 10;
        int n5 = image.getHeight();
        int n6 = 0;
        int n7 = 0;
        do {
            n6 = n % 10;
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n2 -= n4 + 1, n3, n4, n5);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n2 - n6 * n4, n3, 0);
            ++n7;
        } while ((n /= 10) > 0);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        if (bl) {
            this.var_javax_microedition_lcdui_Graphics_a.setColor(15027533);
            this.var_javax_microedition_lcdui_Graphics_a.drawLine(n2 - n4 + 1, n3 + 3, n2 - 1, n3 + 3);
            ++n7;
        }
        return n7;
    }

    private void n() {
        this.actorSpriteImages = new Image[this.var_java_lang_String_arr_m.length];
        this.objectTypeLookupTable = new byte[this.var_java_lang_String_arr_m.length];
        this.var_boolean_arr_c = new boolean[this.var_java_lang_String_arr_m.length];
        int n = this.var_boolean_arr_d.length;
        while (--n >= 0) {
            this.var_boolean_arr_c[n] = this.var_boolean_arr_d[n];
        }
        this.monsterSpecialEffectArray = new byte[this.var_java_lang_String_arr_m.length];
        this.var_int_arr_n = new int[this.var_java_lang_String_arr_m.length];
        this.mapObjectPixelX = new int[100];
        this.mapObjectPixelY = new int[100];
        this.spriteWidthLookupTable = new int[100];
        this.var_int_arr_j = new int[100];
        this.var_int_arr_k = new int[100];
        this.objectIdLookupTable = new int[100];
        this.var_int_arr_m = new int[100];
        this.spritePassable = new boolean[100];
        this.var_boolean_arr_b = new boolean[100];
        this.npcTalkIndexLookupTable = new short[100];
        this.var_byte_arr_e = new byte[100];
        this.monsterSpecialEffectArray[74] = 1;
        this.monsterSpecialEffectArray[53] = 1;
        this.monsterSpecialEffectArray[49] = 1;
        this.monsterSpecialEffectArray[69] = 2;
        for (n = 1; n <= 12; ++n) {
            this.objectTypeLookupTable[n] = 1;
        }
        for (n = 13; n <= 32; ++n) {
            this.objectTypeLookupTable[n] = 2;
        }
        for (n = 33; n <= 40; ++n) {
            this.objectTypeLookupTable[n] = 4;
        }
        for (n = 41; n < 79; ++n) {
            this.objectTypeLookupTable[n] = 8;
        }
        this.objectTypeLookupTable[76] = 1;
        this.objectTypeLookupTable[77] = 16;
        this.objectTypeLookupTable[78] = 16;
        this.objectTypeLookupTable[79] = 4;
        this.objectTypeLookupTable[80] = 4;
        this.objectTypeLookupTable[81] = 1;
        this.objectTypeLookupTable[83] = 1;
        this.objectTypeLookupTable[72] = 32;
        this.objectTypeLookupTable[84] = 32;
        this.objectTypeLookupTable[87] = 32;
        this.objectTypeLookupTable[85] = 2;
        this.objectTypeLookupTable[86] = 2;
        this.objectTypeLookupTable[82] = 1;
    }

    private void initSpriteWidthHeight(int n, int n2) {
        Image image = this.actorSpriteImages[n];
        switch (n) {
            case 69: {
                this.void_a(9);
                this.spriteWidthLookupTable[n2] = 96;
                this.var_int_arr_j[n2] = 32;
                return;
            }
            case 67: {
                this.void_a(9);
                break;
            }
            case 72: {
                this.spriteWidthLookupTable[n2] = 32;
                this.var_int_arr_j[n2] = 45;
                return;
            }
            default: {
                if (image == null) break;
                this.spriteWidthLookupTable[n2] = this.var_byte_arr_h[n];
                this.var_int_arr_j[n2] = image.getHeight();
                return;
            }
        }
        this.spriteWidthLookupTable[n2] = 32;
        this.var_int_arr_j[n2] = 32;
    }

    private void initSpriteProperty(int n, int n2) {
        this.var_int_arr_m[n2] = this.var_byte_arr_g[n];
        this.var_int_arr_k[n2] = 0;
    }

    private void void_d(int n) {
        this.var_byte_arr_e[n] = 2;
        int n2 = this.objectIdLookupTable[n];
        switch (this.objectTypeLookupTable[n2]) {
            case 1: {
                return;
            }
            case 2:
            case 8:
            case 16:
            case 32: {
                this.spriteWidthLookupTable[n] = 27;
                this.var_int_arr_j[n] = 29;
                this.var_int_arr_m[n] = 8;
                this.var_int_arr_k[n] = 0;
            }
        }
    }

    private void void_e(int n) {
        this.var_byte_arr_e[n] = 1;
        int n2 = this.objectIdLookupTable[n];
        switch (this.objectTypeLookupTable[n2]) {
            case 1: {
                switch (n2) {
                    case 1:
                    case 2:
                    case 3: {
                        this.spriteWidthLookupTable[n] = 45;
                        this.var_int_arr_j[n] = 56;
                        this.var_int_arr_m[n] = 6;
                        this.var_int_arr_k[n] = 0;
                        break;
                    }
                    case 11: {
                        this.spriteWidthLookupTable[n] = 45;
                        this.var_int_arr_j[n] = 57;
                        this.var_int_arr_m[n] = 2;
                        this.var_int_arr_k[n] = 0;
                    }
                }
                this.r();
                return;
            }
            case 2:
            case 4: {
                this.spriteWidthLookupTable[n] = 45;
                this.var_int_arr_j[n] = 56;
                this.var_int_arr_m[n] = 10;
                this.var_int_arr_k[n] = 0;
                return;
            }
            case 8:
            case 16:
            case 32: {
                this.spriteWidthLookupTable[n] = 27;
                this.var_int_arr_j[n] = 29;
                this.var_int_arr_m[n] = 6;
                this.var_int_arr_k[n] = 0;
            }
        }
    }

    private int loadSpritePropertyInternal(int objectId, int x, int y, int prop) {
        this.initSpriteWidthHeight(objectId, this.levelActorCount);
        this.initSpriteProperty(objectId, this.levelActorCount);
        int n5 = this.spriteWidthLookupTable[this.levelActorCount] >> 5;
        byte by = 0;
        int n6 = x + 16 >> 5;
        int n7 = y + 16 >> 5;
        int n8 = 0;
        if (n5 <= 0) {
            n5 = 1;
        }
        x = n6 << 5;
        y = n7 << 5;
        this.objectIdLookupTable[this.levelActorCount] = objectId;
        this.mapObjectPixelX[this.levelActorCount] = x;
        this.mapObjectPixelY[this.levelActorCount] = y;
        this.var_boolean_arr_b[this.levelActorCount] = false;
        this.spritePassable[this.levelActorCount] = true;
        this.npcTalkIndexLookupTable[this.levelActorCount] = (short)prop;
        this.var_byte_arr_e[this.levelActorCount] = 0;
        ++this.levelActorCount;
        for (prop = 0; prop < n5; ++prop) {
            by = this.var_byte_arr_arr_c[n7][n6 + n8];
            if (by == 0) {
                this.var_byte_arr_arr_c[n7][n6 + n8] = this.var_byte_p = (byte)(this.var_byte_p + 1);
                by = this.var_byte_p;
            }
            this.var_byte_arr_arr_d[by][this.var_byte_arr_k[by]] = this.levelActorCount;
            byte by2 = by;
            this.var_byte_arr_k[by2] = this.var_byte_arr_k[by2] + 1;
            ++n8;
        }
        if (objectId == 7) {
            this.upperX = x;
            this.upperY = y;
        } else if (objectId == 8) {
            this.downX = x;
            this.downY = y;
        }
        return this.levelActorCount - 1;
    }

    private void void_a(int n, int n2, int n3) {
        n = this.var_byte_arr_arr_c[n2][n];
        n2 = this.var_byte_arr_k[n];
        byte by = 0;
        if (n2 > 0) {
            for (int i = 0; i < n2; ++i) {
                if (this.objectIdLookupTable[this.var_byte_arr_arr_d[n][i] - 1] != n3) {
                    byte by2 = by;
                    by = (byte)(by + 1);
                    this.var_byte_arr_arr_d[n][by2] = this.var_byte_arr_arr_d[n][i];
                    continue;
                }
                this.var_boolean_arr_b[this.var_byte_arr_arr_d[n][i] - 1] = true;
            }
            this.var_byte_arr_k[n] = by;
        }
    }

    private void void_b(int n, int n2, int n3) {
        n = this.var_byte_arr_arr_c[n2][n];
        n2 = this.var_byte_arr_k[n];
        if (this.var_byte_arr_k[n] > 0) {
            this.var_boolean_arr_b[this.var_byte_arr_arr_d[n][n3] - 1] = true;
            while (n3 < n2 - 1) {
                this.var_byte_arr_arr_d[n][n3] = this.var_byte_arr_arr_d[n][n3 + 1];
                ++n3;
            }
            int n4 = n;
            this.var_byte_arr_k[n4] = this.var_byte_arr_k[n4] - 1;
        }
    }

    private void void_f(int n) {
        byte by = this.var_byte_arr_arr_c[this.mapObjectPixelY[n] >> 5][this.mapObjectPixelX[n] >> 5];
        int n2 = this.var_byte_arr_k[by];
        this.var_boolean_arr_b[n] = true;
        if (n2 > 0) {
            for (int i = 0; i < n2; ++i) {
                if (this.var_byte_arr_arr_d[by][i] - 1 != n) continue;
                for (n = i; n < n2 - 1; ++n) {
                    this.var_byte_arr_arr_d[by][n] = this.var_byte_arr_arr_d[by][n + 1];
                }
                byte by2 = by;
                this.var_byte_arr_k[by2] = this.var_byte_arr_k[by2] - 1;
                return;
            }
        }
    }

    private void o() {
        if (this.var_boolean_j) {
            if (++this.var_int_U > 1) {
                this.var_boolean_j = false;
                return;
            }
        } else if (--this.var_int_U < -1) {
            this.var_boolean_j = true;
        }
    }

    /*
     * Enabled aggressive block sorting
     */
    private void a(int n, int n2, boolean bl) {
        int n3;
        int n4;
        int n5;
        int n6;
        int n7;
        int n8;
        Object var4_4 = null;
        var4_4 = null;
        boolean bl2 = false;
        int n9 = 0;
        byte by = 0;
        bl2 = false;
        int n10 = 0;
        this.o();
        bl = false;
        block12: for (int i = 0; i < this.levelActorCount; ++i) {
            if (this.var_boolean_arr_b[i] || !this.spritePassable[i]) continue;
            n8 = this.mapObjectPixelX[i];
            n7 = this.mapObjectPixelY[i];
            n6 = this.spriteWidthLookupTable[i];
            n5 = this.var_int_arr_j[i];
            n10 = this.var_byte_arr_e[i];
            n4 = n + n8;
            n3 = n2 + n7;
            if (n4 < -n6 || n4 > this.preferWidth || n3 < -12 || n3 > 20 + this.perferHeight) continue;
            n9 = this.objectIdLookupTable[i];
            Object object = this.actorSpriteImages[n9];
            if (object != null) {
                by = this.objectTypeLookupTable[n9];
                if (!bl && this.playerPixelX > n8 - 32 && this.playerPixelX < n8 + 32 && this.playerPixelY >= n7 - 32 && n7 > this.playerPixelY && !this.var_boolean_arr_c[n9]) {
                    this.void_c(n, n2);
                    bl = true;
                }
                n8 = n6 * this.var_int_arr_arr_c[this.var_int_arr_m[i]][this.var_int_arr_k[i]];
                n7 = 0;
                switch (by) {
                    case 1: {
                        if (n9 == 6) {
                            n3 += 5 - this.var_int_U;
                        } else if (n9 == 9) {
                            n4 += 32;
                        }
                        if (this.var_byte_arr_e[i] != 1) {
                            this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 32), n8, 0, n6, n5);
                            continue block12;
                        }
                        this.a(this.gamePngImagesGroups[4][12], n4 + (32 - n6 >> 1), n3 - (n5 - 32), n8, 0, n6, n5);
                        continue block12;
                    }
                    case 4: {
                        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[5][0], n4 + 8, n3 + 22, 0);
                        this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 24) + this.var_int_U, n8, 0, n6, n5);
                        continue block12;
                    }
                    case 16: {
                        if (n10 == 1 || n10 == 2) {
                            this.a(this.gamePngImagesGroups[2][9], n4 + 2, n3 + 2 - (this.var_int_arr_k[i] << 3), n8, 0, 27, 29);
                            continue block12;
                        }
                        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.actorSpriteImages[15], n4 + 1, n3 + 8 + this.var_int_U, 0);
                        this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 24) + this.var_int_U, n8, 0, n6, n5);
                        continue block12;
                    }
                    case 32: {
                        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[5][0], n4 + 8, n3 + 22, 0);
                        if (n10 == 1 || n10 == 2) {
                            this.a(this.gamePngImagesGroups[2][9], n4 + 2, n3 + 2 - (this.var_int_arr_k[i] << 3), n8, 0, 27, 29);
                            continue block12;
                        }
                        if (n9 != 72) {
                            this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 16) + this.var_int_U, n8, 0, n6, n5);
                            continue block12;
                        }
                        if (i != this.bx) {
                            this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 32), n8, 0, n6, n5);
                            continue block12;
                        }
                        n7 = n5 * this.var_byte_t;
                        if (this.var_byte_t == 3) {
                            this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 32), n8, n7 -= n5, n6, n5, 1);
                            continue block12;
                        }
                        this.a((Image)object, n4 + (32 - n6 >> 1), n3 - (n5 - 32), n8, n7, n6, n5);
                        continue block12;
                    }
                    case 8: {
                        if (n10 == 3) {
                            n4 += this.int_g(5) - 2;
                            n3 += this.int_g(5) - 2;
                        }
                        if (n10 == 1 || n10 == 2) {
                            this.a(this.gamePngImagesGroups[2][9], n4 + 2, n3 + 2 - (this.var_int_arr_k[i] << 3), n8, 0, 27, 29);
                        } else if (n9 == 67 || n9 == 69) {
                            n6 = n3;
                            n7 = n4;
                            n8 = i;
                            object = this;
                            n5 = ((a)object).objectIdLookupTable[n8];
                            n8 = ((a)object).var_int_arr_arr_c[((a)object).var_int_arr_m[n8]][((a)object).var_int_arr_k[n8]];
                            switch (n5) {
                                case 67: {
                                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[5][0], n7 + 8, n6 + 22, 0);
                                    int n11 = n7 + 16;
                                    int n12 = n6 + 16;
                                    n6 = n8;
                                    n7 = n12;
                                    n8 = n11;
                                    byte[] byArray = ((a)object).var_byte_arr_arr_b[n6];
                                    byte[] byArray2 = null;
                                    for (n10 = 0; n10 < byArray.length; n10 += 4) {
                                        byArray2 = ((a)object).var_byte_arr_arr_a[byArray[n10]];
                                        by = byArray2[0];
                                        this.a(((a)object).gamePngImagesGroups[9][by], n8 + byArray[n10 + 1], n7 + byArray[n10 + 2], byArray2[1], byArray2[2], byArray2[3], byArray2[4]);
                                    }
                                    break;
                                }
                                case 69: {
                                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).gamePngImagesGroups[5][0], n7 + 40, n6 + 22, 0);
                                    n6 -= 49;
                                    ((a)object).var_javax_microedition_lcdui_Graphics_a.drawImage(((a)object).actorSpriteImages[n5], n7 += 3, n6 += ((a)object).var_int_U, 0);
                                    if (n8 > 0) {
                                        this.a(((a)object).gamePngImagesGroups[9][5], n7 + 32, n6 + 27, 26 * (n8 - 1), 0, 26, 13);
                                    } else {
                                        break;
                                    }
                                }
                            }
                        } else {
                            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[5][0], n4 + 8, n3 + 22, 0);
                            this.a((Image)object, n4 + (32 - n6 >> 1), (n3 -= 4) - (n5 - 32), n8, 0, n6, n5);
                        }
                        if (this.var_byte_l != 2 || !this.var_boolean_i) break;
                        int n13 = this.var_int_arr_n[n9];
                        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[2][8], n4 - 3 + this.var_byte_arr_b[this.var_int_d & 7], n3 - 24 + this.var_byte_arr_c[this.var_int_d & 7], 0);
                        if (n13 >= 0) {
                            this.b(this.gamePngImagesGroups[2][7], this.var_int_arr_n[n9], n4 + 30 + this.var_byte_arr_b[this.var_int_d & 7], n3 - 17 + this.var_byte_arr_c[this.var_int_d & 7]);
                            continue block12;
                        }
                        this.a(this.gamePngImagesGroups[2][7], n4 + 14 + this.var_byte_arr_b[this.var_int_d & 7], n3 - 17 + this.var_byte_arr_c[this.var_int_d & 7], 70, 0, 7, 9);
                        continue block12;
                    }
                    case 2: {
                        if (n10 == 1) {
                            this.a(this.gamePngImagesGroups[4][12], n4 + (32 - n6 >> 1), n3 - (n5 - 32), n8, 0, n6, n5);
                            continue block12;
                        }
                        if (n10 == 2) {
                            this.a(this.gamePngImagesGroups[2][9], n4 + 2, n3 + 2 - (this.var_int_arr_k[i] << 3), n8, 0, 27, 29);
                            continue block12;
                        }
                        if (n9 < 26) {
                            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[5][0], n4 + 8, n3 + 22, 0);
                            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.actorSpriteImages[n9], n4 + (32 - n6 >> 1), n3 - (n5 - 24) + this.var_int_U, 0);
                            continue block12;
                        }
                        this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.actorSpriteImages[n9], n4 + (32 - n6 >> 1), n3 - (n5 - 30), 0);
                    }
                }
                continue;
            }
            object = this.var_java_lang_String_arr_m[this.objectIdLookupTable[i]];
            int n14 = this.var_javax_microedition_lcdui_Font_a.stringWidth((String)object) + 8 >> 1;
            this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
            this.var_javax_microedition_lcdui_Graphics_a.fillArc(n4, n3, 32, 32, 0, 360);
            this.var_javax_microedition_lcdui_Graphics_a.fillRect(n4 -= n14 - 16, n3 += 32 - this.var_int_b >> 1, n14 << 1, this.var_int_b);
            this.var_javax_microedition_lcdui_Graphics_a.setColor(0);
            this.var_javax_microedition_lcdui_Graphics_a.drawRect(n4, n3, (n14 << 1) - 1, this.var_int_b - 1);
            this.var_javax_microedition_lcdui_Graphics_a.drawString(this.var_java_lang_String_arr_m[this.objectIdLookupTable[i]], n4 + 4, n3, 0);
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        if (!bl) {
            this.void_c(n, n2);
        }
        if (this.var_byte_l == 5) {
            a a2 = this;
            if (a2.var_int_S >= 0) {
                n8 = a2.ae + a2.var_int_arr_g[a2.var_int_S] + 16;
                n7 = a2.af + a2.var_int_arr_h[a2.var_int_S] + 32;
                n6 = a2.bV & 7;
                n5 = a2.var_byte_arr_S[n6];
                if (n5 > 0) {
                    n5 = n5 - 1 << 2;
                    a2.a(a2.var_javax_microedition_lcdui_Image_arr_arr_a[3][2], n8 - (a2.var_byte_arr_R[n5 + 2] >> 1), n7 - (a2.var_byte_arr_R[n5 + 3] >> 1), a2.var_byte_arr_R[n5], a2.var_byte_arr_R[n5 + 1], a2.var_byte_arr_R[n5 + 2], a2.var_byte_arr_R[n5 + 3]);
                }
            }
        }
        if (this.upperX >= 0) {
            n4 = n + this.upperX;
            n3 = n2 + this.upperY;
            if (n4 >= -32 && n4 <= this.preferWidth && n3 >= -12 && n3 <= 20 + this.perferHeight) {
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[2][1], n4 + 5, n3 - 30 + this.var_int_U, 0);
            }
        }
        if (this.downX >= 0) {
            n4 = n + this.downX;
            n3 = n2 + this.downY;
            if (n4 >= -32 && n4 <= this.preferWidth && n3 >= -12 && n3 <= 20 + this.perferHeight) {
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[2][2], n4, n3 - 30 + this.var_int_U, 0);
            }
        }
    }

    private void p() {
        int n = 0;
        int n2 = 0;
        if (this.levelActorCount > 0) {
            for (int i = this.levelActorCount; i >= 1; --i) {
                n = this.mapObjectPixelY[0];
                for (int j = 1; j < i; ++j) {
                    if (this.var_boolean_arr_b[j]) continue;
                    n2 = this.mapObjectPixelY[j];
                    if (n2 < n) {
                        int n3;
                        int n4;
                        int n5 = j;
                        n2 = j - 1;
                        a a2 = this;
                        int n6 = a2.objectIdLookupTable[n2];
                        int n7 = a2.var_int_arr_g[n2];
                        int n8 = a2.var_int_arr_h[n2];
                        int n9 = a2.var_int_arr_i[n2];
                        int n10 = a2.var_int_arr_j[n2];
                        byte by = a2.var_byte_arr_e[n2];
                        boolean bl = a2.var_boolean_arr_b[n2];
                        boolean bl2 = a2.var_boolean_arr_a[n2];
                        short s = a2.npcTalkIndexLookupTable[n2];
                        int n11 = n9 >> 5;
                        if (n11 <= 0) {
                            n11 = 1;
                        }
                        int n12 = n8 >> 5;
                        int n13 = n7 >> 5;
                        byte by2 = 0;
                        int n14 = 0;
                        block2: for (n4 = 0; n4 < n11; ++n4) {
                            by2 = a2.var_byte_arr_arr_c[n12][n13 + n4];
                            n14 = a2.var_byte_arr_k[by2];
                            for (n3 = 0; n3 < n14; ++n3) {
                                if (a2.var_byte_arr_arr_d[by2][n3] != n2 + 1) continue;
                                a2.var_byte_arr_arr_d[by2][n3] = n5 + 1;
                                continue block2;
                            }
                        }
                        a2.objectIdLookupTable[n2] = a2.objectIdLookupTable[n5];
                        a2.var_int_arr_g[n2] = a2.var_int_arr_g[n5];
                        a2.var_int_arr_h[n2] = a2.var_int_arr_h[n5];
                        a2.var_int_arr_i[n2] = a2.var_int_arr_i[n5];
                        a2.var_int_arr_j[n2] = a2.var_int_arr_j[n5];
                        a2.var_byte_arr_e[n2] = a2.var_byte_arr_e[n5];
                        a2.var_boolean_arr_b[n2] = a2.var_boolean_arr_b[n5];
                        a2.var_boolean_arr_a[n2] = a2.var_boolean_arr_a[n5];
                        a2.npcTalkIndexLookupTable[n2] = a2.npcTalkIndexLookupTable[n5];
                        a2.g(a2.objectIdLookupTable[n2], n2);
                        a2.objectIdLookupTable[n5] = n6;
                        a2.var_int_arr_g[n5] = n7;
                        a2.var_int_arr_h[n5] = n8;
                        a2.var_int_arr_i[n5] = n9;
                        a2.var_int_arr_j[n5] = n10;
                        a2.var_byte_arr_e[n5] = by;
                        a2.var_boolean_arr_b[n5] = bl;
                        a2.var_boolean_arr_a[n5] = bl2;
                        a2.npcTalkIndexLookupTable[n5] = s;
                        a2.g(a2.objectIdLookupTable[n5], n5);
                        n12 = a2.var_int_arr_h[n2] >> 5;
                        n13 = a2.var_int_arr_g[n2] >> 5;
                        n11 = a2.var_int_arr_i[n2] >> 5;
                        if (n11 <= 0) {
                            n11 = 1;
                        }
                        block4: for (n4 = 0; n4 < n11; ++n4) {
                            by2 = a2.var_byte_arr_arr_c[n12][n13 + n4];
                            n14 = a2.var_byte_arr_k[by2];
                            for (n3 = 0; n3 < n14; ++n3) {
                                if (a2.var_byte_arr_arr_d[by2][n3] != n5 + 1) continue;
                                a2.var_byte_arr_arr_d[by2][n3] = n2 + 1;
                                continue block4;
                            }
                        }
                        n2 = this.mapObjectPixelY[j];
                    }
                    n = n2;
                }
            }
        }
    }

    private void q() {
        int n = 0;
        if (this.levelActorCount > 0 && (this.var_int_d & 1) != 0) {
            int n2 = this.levelActorCount;
            block4: while (--n2 >= 0) {
                if (this.var_boolean_arr_b[n2] || !this.spritePassable[n2] || (n = this.var_int_arr_m[n2]) <= 0) continue;
                if (this.var_int_arr_k[n2] < this.var_int_arr_arr_c[n].length - 1) {
                    int n3 = n2;
                    this.var_int_arr_k[n3] = this.var_int_arr_k[n3] + 1;
                    continue;
                }
                switch (this.var_byte_arr_e[n2]) {
                    case 1: {
                        this.void_f(n2);
                        continue block4;
                    }
                    case 2: {
                        this.initSpriteWidthHeight(this.objectIdLookupTable[n2], n2);
                        this.initSpriteProperty(this.objectIdLookupTable[n2], n2);
                        this.var_byte_arr_e[n2] = 0;
                        continue block4;
                    }
                }
                this.var_int_arr_k[n2] = 0;
            }
        }
    }

    private void void_a(boolean n) {
        int n2 = 0;
        int n3 = 0;
        if (--this.X < -154) {
            this.X = 0;
        }
        boolean bl = false;
        n3 = n == 0 ? 0 : this.var_int_W - 320 + 6;
        for (n2 = this.X; n2 < 240; n2 += 77) {
            for (n = n3; n > -320; n -= 320) {
                if (bl) {
                    this.void_a(this.gamePngImagesGroups[1][0], n2, n, 2);
                } else {
                    this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[1][0], n2, n, 0);
                }
                bl = !bl;
            }
            bl = false;
        }
    }

    private void r() {
        this.var_javax_microedition_lcdui_Image_d = null;
        if (this.var_boolean_arr_f[1]) {
            Image image = Image.createImage((int)(this.m_mapWidth << 2), (int)(this.m_mapHeight << 2));
            Graphics graphics = image.getGraphics();
            int n = 0;
            int n2 = 0;
            graphics.setColor(13097429);
            graphics.fillRect(0, 0, this.m_mapWidth << 2, this.m_mapHeight << 2);
            graphics.setColor(7509153);
            byte by = 0;
            int n3 = 0;
            while (n3 < this.m_mapHeight) {
                int n4 = 0;
                while (n4 < this.m_mapWidth) {
                    by = this.var_byte_arr_arr_c[n3][n4];
                    if (this.mapPassBitmap[n3][n4]) {
                        graphics.setColor(7509153);
                        graphics.fillRect(n, n2, 4, 4);
                    }
                    if (by > 0 && this.var_byte_arr_k[by] > 0 && !this.var_boolean_arr_b[(by = this.var_byte_arr_arr_d[by][0]) - 1] && this.var_byte_arr_e[by - 1] != 1) {
                        switch (this.objectIdLookupTable[by - 1]) {
                            case 1: {
                                graphics.setColor(0xEBEB4E);
                                graphics.fillRect(n, n2, 3, 3);
                                graphics.setColor(9794048);
                                graphics.drawLine(n + 3, n2, n + 3, n2 + 3);
                                graphics.drawLine(n, n2 + 3, n + 3, n2 + 3);
                                break;
                            }
                            case 3: {
                                graphics.setColor(4767984);
                                graphics.fillRect(n, n2, 3, 3);
                                graphics.setColor(549016);
                                graphics.drawLine(n + 3, n2, n + 3, n2 + 3);
                                graphics.drawLine(n, n2 + 3, n + 3, n2 + 3);
                                break;
                            }
                            case 2: {
                                graphics.setColor(16273480);
                                graphics.fillRect(n, n2, 4, 4);
                                graphics.setColor(0x800000);
                                graphics.drawLine(n + 3, n2, n + 3, n2 + 3);
                                graphics.drawLine(n, n2 + 3, n + 3, n2 + 3);
                                break;
                            }
                            case 7: {
                                a.a(this.gamePngImagesGroups[8][12], graphics, n - 1, n2 - 1, 5, 0, 5, 5);
                                break;
                            }
                            case 8: {
                                a.a(this.gamePngImagesGroups[8][12], graphics, n - 1, n2 - 1, 0, 0, 5, 5);
                            }
                        }
                    }
                    ++n4;
                    n += 4;
                }
                ++n3;
                n2 += 4;
                n = 0;
            }
            this.var_javax_microedition_lcdui_Image_d = image = a.a(image, 170);
        }
    }

    private static short readBinaryShort(InputStream inputStream) throws IOException {
        return (short)(inputStream.read() & 0xFF | inputStream.read() << 8 & 0xFF00);
    }

    private void s() {
        this.var_byte_arr_arr_c = new byte[this.m_mapHeight][this.m_mapWidth];
        this.var_byte_arr_k = new byte[128];
        this.var_byte_arr_arr_d = new byte[128][16];
        this.var_byte_p = 0;
    }

    private boolean boolean_b(int n, int n2) {
        if (n >= 0 && n < this.m_mapWidth && n2 >= 0 && n2 < this.m_mapHeight) {
            return this.mapPassBitmap[n2][n];
        }
        return false;
    }

    private void initPassthrough() {
        int n = 0;
        byte by = 0;
        int n2 = this.m_mapWidth;
        int n3 = this.m_mapHeight;
        int n4 = 0;
        while (n4 < n3) {
            int n5 = 0;
            while (n5 < n2) {
                by = this.passableArray[n];
                this.mapPassBitmap[n4][n5] = by < this.var_boolean_arr_e.length ? this.var_boolean_arr_e[by] : false;
                ++n5;
                n += 2;
            }
            ++n4;
            n += n2 << 1;
        }
    }

    private boolean boolean_c(int n, int n2) {
        if (n >= 0 && n < this.m_mapWidth && n2 >= 0 && n2 < this.m_mapHeight) {
            return this.var_byte_arr_k[this.var_byte_arr_arr_c[n2][n]] > 0;
        }
        return false;
    }

    private void h(int n, int n2) {
        int n3;
        int n4;
        if (this.var_byte_l == 4) {
            a a2 = this;
            ++a2.ad;
            if (a2.ad == 18) {
                a a3 = a2;
                n4 = 0;
                n3 = a3.aI;
                while (--n3 >= 0) {
                    n4 = a3.var_short_arr_d[n3];
                    a3.var_int_arr_m[n4] = 6;
                    a3.var_byte_arr_e[n4] = 1;
                }
            } else if (a2.ad >= 24) {
                a2.ad = 0;
                a a4 = a2;
                for (n4 = 0; n4 < a4.aI; ++n4) {
                    a4.void_a((int)a4.var_short_arr_b[n4], (int)a4.var_short_arr_c[n4], 4);
                }
                a4.aI = 0;
                a2.ac = 0;
                a2.var_byte_l = 0;
            }
            a2.ac = a2.ac == -2 ? 2 : -2;
            n2 = 20 + this.ac;
        }
        n = this.ae + (this.ai << 4);
        n2 = this.af + n2 + (this.ak << 4);
        n4 = 0;
        int n5 = n;
        int n6 = n2;
        n2 = n3 = this.ai + (this.ak * this.m_mapWidth << 1);
        int n7 = this.ak;
        while (n7 < this.al) {
            int n8 = this.ai;
            while (n8 < this.aj) {
                n4 = this.passableArray[n2];
                if (n4 > 0) {
                    int n9 = (n4 & 7) << 4;
                    n4 = n4 >> 3 << 4;
                    this.a(this.gamePngImagesGroups[2][0], n5, n6, n9, n4, 16, 16, this.tileOperateModeArray[n2]);
                }
                ++n8;
                ++n2;
                n5 += 16;
            }
            ++n7;
            n6 += 16;
            n5 = n;
            n2 = n3 += this.m_mapWidth << 1;
        }
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
    }

    private void i(int n, int n2) {
        if (!this.var_boolean_k) {
            if (n > 64) {
                n = 64;
            } else if (n < -((this.m_mapWidth + 2 << 5) - this.preferWidth)) {
                n = -((this.m_mapWidth + 2 << 5) - this.preferWidth);
            }
            this.ae = n;
            if (n < 0) {
                this.ai = -n >> 4;
                this.aj = this.ai + (this.preferWidth >> 4) + 1;
            } else {
                this.ai = 0;
                this.aj = (this.preferWidth - n >> 4) + 1;
            }
            if (this.aj > this.m_mapWidth << 1) {
                this.aj = this.m_mapWidth << 1;
            }
            if (n2 > 64) {
                n2 = 64;
            } else if (n2 < -((this.m_mapHeight + 2 << 5) - this.perferHeight)) {
                n2 = -((this.m_mapHeight + 2 << 5) - this.perferHeight);
            }
        } else {
            this.ae = this.preferWidth - this.pixelWidth >> 1;
            this.ai = 0;
            this.aj = this.m_mapWidth << 1;
        }
        if (!this.var_boolean_l) {
            this.af = n2;
            if (n2 < 0) {
                this.ak = -n2 >> 4;
                this.al = this.ak + (this.perferHeight >> 4) + 2;
            } else {
                this.ak = 0;
                this.al = (this.perferHeight - n2 >> 4) + 1;
            }
            if (this.al > this.m_mapHeight << 1) {
                this.al = this.m_mapHeight << 1;
                return;
            }
        } else {
            this.af = this.perferHeight - this.pixelHeight >> 1;
            this.ak = 0;
            this.al = this.m_mapHeight << 1;
        }
    }

    private int int_a(boolean bl) {
        if (bl) {
            for (int i = 0; i < this.levelActorCount; ++i) {
                int n = this.npcTalkIndexLookupTable[i] >> 9;
                if (this.objectIdLookupTable[i] != 7 || n != 0) continue;
                return i;
            }
        } else {
            for (int i = 0; i < this.levelActorCount; ++i) {
                int n = this.npcTalkIndexLookupTable[i] >> 9;
                if (this.objectIdLookupTable[i] != 8 || n != 0) continue;
                return i;
            }
        }
        return -1;
    }

    /*
     * Unable to fully structure code
     */
    private boolean a(int var1_1, boolean var2_2, boolean var3_3) {
        var4_4 = false;
        if (!var3_3) ** GOTO lbl-1000
        if (var1_1 < this.an) {
            this.a((byte)0, this.var_java_lang_String_arr_a[0], (byte)0, (byte)0);
            var4_4 = false;
        } else if (var1_1 > this.ao) {
            var4_4 = false;
            this.a((byte)0, this.var_java_lang_String_arr_a[1], (byte)0, (byte)0);
        } else lbl-1000:
        // 2 sources

        {
            var4_4 = true;
        }
        if (var4_4) {
            var4_4 = false;
            if (var1_1 < 0) {
                this.a((byte)0, this.var_java_lang_String_arr_a[2], (byte)0, (byte)0);
            } else if (var1_1 > this.aq) {
                this.a((byte)0, this.var_java_lang_String_arr_a[3], (byte)0, (byte)0);
            } else {
                var4_4 = true;
                this.var_boolean_q = true;
                if (var1_1 < this.an) {
                    this.an = var1_1;
                } else if (var1_1 > this.ao) {
                    this.ao = var1_1;
                    if (this.ao < 51 && this.ao > this.bY) {
                        this.bY = this.ao;
                    }
                }
                this.r(this.level);
                this.var_byte_x = (byte)var1_1;
                this.var_boolean_s = var2_2;
            }
        }
        return var4_4;
    }

    private void u() {
        this.a((byte)3, true);
        this.u(6);
        this.u(8);
        this.u(5);
        this.u(13);
        this.u(9);
        this.u(10);
        this.u(2);
        this.u(3);
        this.u(12);
        this.u(11);
    }

    private void v() {
        int n;
        this.playerWeapon = 0;
        this.playerCloth = 0;
        if (this.level == 1) {
            this.void_a(6, 11);
        } else if (this.level == 51) {
            this.void_a(1, 11);
        } else if (this.level == 50) {
            this.void_a(6, 6);
        } else {
            n = this.int_a(false);
            if (n >= 0) {
                this.void_b(this.mapObjectPixelX[n] >> 5, this.mapObjectPixelY[n] >> 5);
            }
        }
        n = this.bj;
        while (--n >= 0) {
            this.var_boolean_arr_g[n] = false;
        }
        this.aL = 0;
        this.aQ = 0;
        this.ar = 0;
        this.bagItemCount = 0;
        this.var_byte_A = 0;
        this.void_g(this.var_int_arr_H[this.var_byte_A]);
    }

    private void void_g(int n) {
        if (this.monsterAttackArray == null) {
            this.monsterAttackArray = new int[this.var_int_arr_q.length];
        }
        int n2 = this.monsterAttackArray.length;
        while (--n2 >= 0) {
            this.monsterAttackArray[n2] = this.var_int_arr_q[n2] * n;
        }
        if (this.monsterDefArray == null) {
            this.monsterDefArray = new int[this.var_int_arr_r.length];
        }
        n2 = this.monsterDefArray.length;
        while (--n2 >= 0) {
            this.monsterDefArray[n2] = this.var_int_arr_r[n2] * n;
        }
        if (this.monsterHpArray == null) {
            this.monsterHpArray = new int[this.monsterHpBaseArray.length];
        }
        n2 = this.monsterHpArray.length;
        while (--n2 >= 0) {
            this.monsterHpArray[n2] = this.monsterHpBaseArray[n2] * n;
        }
    }

    private static int int_a(int n, int n2) {
        --n2;
        n2 /= 10;
        return n * ++n2;
    }

    private static int int_b(int n) {
        int n2 = 20;
        for (int i = 1; i < n; ++i) {
            n2 += 20 * i;
        }
        return n2;
    }

    private void void_h(int n) {
        int n2 = this.var_javax_microedition_lcdui_Font_a.stringWidth(this.var_java_lang_String_arr_f[n]) + 80;
        this.var_byte_arr_l[this.aF++] = n;
        if (this.aF == 1) {
            this.aH = 32 + this.aD;
            this.aG = n2;
        } else {
            this.aH += this.aD;
            if (this.aG < n2) {
                this.aG = n2;
            }
        }
        switch (n) {
            case 0: {
                this.var_boolean_arr_f[this.aF - 1] = this.var_boolean_D;
            }
        }
    }

    private boolean boolean_b(int n) {
        int n2 = 0;
        this.aI = 0;
        for (int i = 0; i < this.levelActorCount; ++i) {
            if (this.var_boolean_arr_b[i] || n != this.npcTalkIndexLookupTable[i]) continue;
            n2 = this.objectIdLookupTable[i];
            if (n2 == 5) {
                return false;
            }
            if (n2 != 4) continue;
            this.var_short_arr_d[this.aI] = i;
            this.var_short_arr_b[this.aI] = this.mapObjectPixelX[i] >> 5;
            this.var_short_arr_c[this.aI] = this.mapObjectPixelY[i] >> 5;
            ++this.aI;
        }
        return this.aI > 0;
    }

    private boolean boolean_a(boolean bl) {
        short s = this.npcTalkIndexLookupTable[this.currentBussinessManId];
        byte by = (byte)(s >>> 8);  //应该等同于 >> 8
        s = (byte)s;
        int isBusninessMan = this.objectIdLookupTable[this.currentBussinessManId] == 77 ? 0 : 1;   //太白金星
        boolean bl2 = true;
        boolean bl3 = false;
        if (s <= 0) {
            return false;
        }
        if (bl) {
            if ((by & 2) != 0) {
                block0 : switch (isBusninessMan) {
                    case 0: {
                        switch (s) {
                            case 2: {
                                this.equipItem(13);     //火眼金睛
                                break;
                            }
                            case 1:
                            case 15:
                            case 21: {
                                this.addMoney(1000, this.playerPixelX, this.playerPixelY);
                                break;
                            }
                            case 6: {
                                this.equipItem(19);     //千年月桂露
                            }
                        }
                        break;
                    }
                    case 1: {
                        switch (s) {
                            case 1: {
                                this.playerAttack += this.playerAttack * 3 / 100;
                                this.playerAmaor += this.playerAmaor * 3 / 100;
                                break block0;
                            }
                            case 3: {
                                if (this.useMoney(50)) {
                                    ++this.blueKeyCount;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 4: {
                                if (this.useMoney(50)) {
                                    this.yellowKeyCount += 5;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 5: {
                                //1000块一把黄钥匙
                                if (this.useMoney(1000)) {
                                    ++this.yellowKeyCount;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 6: {
                                if (this.useMoney(800)) {
                                    ++this.redKeyCount;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 7: {
                                if (this.useMoney(200)) {
                                    ++this.blueKeyCount;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 8: {
                                if (this.yellowKeyCount > 0) {
                                    --this.yellowKeyCount;
                                    this.aQ += 100;
                                    break block0;
                                }
                                this.a((byte)0, "没有黄钥匙", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 9: {
                                if (this.useMoney(1000)) {
                                    ++this.yellowKeyCount;
                                    ++this.blueKeyCount;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 10: {
                                if (this.useMoney(200)) {
                                    this.yellowKeyCount += 3;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 11: {
                                if (this.useMoney(2000)) {
                                    this.blueKeyCount += 3;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 12: {
                                if (this.useMoney(1000)) {
                                    this.playerHp += 2000;
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                                break block0;
                            }
                            case 13: {
                                if (this.useMoney(4000)) {
                                    this.pickupGroundItem(18);
                                    break block0;
                                }
                                this.a((byte)0, "没有足够的金钱", (byte)0, (byte)0);
                                bl2 = false;
                            }
                        }
                    }
                }
                if (bl2) {
                    if ((by & 4) == 0) {
                        int n2 = this.currentBussinessManId;
                        this.npcTalkIndexLookupTable[n2] = this.npcTalkIndexLookupTable[n2] ^ 0x200;
                        if ((by & 1) != 0) {
                            this.j(isBusninessMan, s - 1);
                            if (isBusninessMan == 0) {
                                this.a((byte)4, this.var_java_lang_String_arr_g[s - 1], (byte)0, (byte)0);
                            } else {
                                this.a((byte)4, this.var_java_lang_String_arr_j[s - 1], (byte)0, (byte)0);
                            }
                            bl3 = true;
                        } else {
                            this.void_e(this.currentBussinessManId);
                        }
                    }
                } else {
                    bl3 = true;
                }
            } else if ((by & 1) != 0) {
                int n3 = this.currentBussinessManId;
                this.npcTalkIndexLookupTable[n3] = this.npcTalkIndexLookupTable[n3] ^ 0x100;
                if ((by & 4) == 0) {
                    this.void_e(this.currentBussinessManId);
                }
            }
        } else if ((by & 2) == 0 && (by & 1) != 0) {
            int n4 = this.currentBussinessManId;
            this.npcTalkIndexLookupTable[n4] = this.npcTalkIndexLookupTable[n4] ^ 0x100;
            if ((by & 4) == 0) {
                this.void_e(this.currentBussinessManId);
            }
        }
        return bl3;
    }

    private void j(int n, int n2) {
        if (this.aL < this.aK) {
            this.var_byte_arr_o[this.aL] = n;
            this.var_byte_arr_p[this.aL] = n2;
            ++this.aL;
        }
    }

    private void i(int n) {
        byte by = 0;
        byte by2 = 0;
        if (this.aL > 0) {
            this.level = n < 0 ? this.aL - 1 : (n >= this.aL ? 0 : n);
            by = this.var_byte_arr_o[this.level];
            by2 = this.var_byte_arr_p[this.level];
            if (by == 0) {
                this.a((byte)5, this.var_java_lang_String_arr_g[by2], (byte)0, (byte)3);
            } else {
                this.a((byte)5, this.var_java_lang_String_arr_j[by2], (byte)0, (byte)3);
            }
            this.var_java_lang_String_e = "" + (this.level + 1) + " / " + this.aL;
            return;
        }
        this.a((byte)0, "没有记录", (byte)0, (byte)3);
        this.gameStateFlag = (byte)10;
    }

    private boolean useMoney(int n) {
        boolean bl = true;
        if (this.aQ >= n) {
            this.aQ -= n;
        } else {
            bl = false;
        }
        return bl;
    }

    private void addMoney(int n, int n2, int n3) {
        this.aQ += n;
        if (n > 0) {
            this.a((byte)4, n, n2, n3);
        }
    }

    private void pickupGroundItem(int n) {
        int n2 = 0;
        n2 = this.convertEquipIdToOrderArrayIndex(n, 0, 12);
        switch (n) {
            case 33:        //桃木棒
            case 34:        //玄铁棒
            case 35:        //真银棒
            case 36:        //金箍棒
            case 37:        //道袍
            case 38:        //铁甲
            case 39:        //锁子甲
            case 40:        //紫金龙鳞甲
            case 79:        //乌金棍
            case 80: {      //银缕锁甲
                if (this.changeEquipWeaponCloth(n2, false)) {
                    this.playerCurrentEquipItemId = (byte)n;
                    this.a((byte)1, this.equipItemDescribs[n2], (byte)0, (byte)3);
                    return;
                }
                this.a((byte)0, this.var_java_lang_String_arr_a[5], (byte)0, (byte)3);
                return;
            }
            case 15: {      //筋斗云
                this.isJDYEnabled = true;
            }
            case 13:        //火眼金睛
            case 14:        //生死簿
            case 16:        //芭蕉扇
            case 17:        //金勺子
            case 18:        //玄明石
            case 19:        //千年月桂露
            case 20:        //相形变位
            case 21:        //上行符
            case 22:        //下行符
            case 23:        //太公杖
            case 24:        //捆仙绳
            case 25:        //幸运币
            case 85:        //黄金钥匙
            case 86: {      //日月无极钹
                this.equipItem(n);
                return;
            }
            case 26: {      //黄钥匙
                ++this.yellowKeyCount;
                return;
            }
            case 27: {      //红钥匙
                ++this.redKeyCount;
                return;
            }
            case 28: {      //蓝钥匙
                ++this.blueKeyCount;
                return;
            }
            case 29: {      //威力丹
                if (this.level <= 10) {
                    ++this.playerAttack;
                    return;
                }
                this.playerAttack += this.getPropertyItemValue();
                return;
            }
            case 30: {      //金刚丹
                if (this.level <= 10) {
                    ++this.playerAmaor;
                    return;
                }
                this.playerAmaor += this.getPropertyItemValue();
                return;
            }
            case 31: {      //回春丸
                n2 = this.getPropertyItemValue();
                this.updateHp(50 * n2);
                return;
            }
            case 32: {      //长寿丹
                n2 = this.getPropertyItemValue();
                this.updateHp(200 * n2);
            }
        }
    }

    private int getPropertyItemValue() {
        int n = this.level - 1;
        if ((n /= 10) < 0) {
            n = 0;
        }
        if (this.level > 50) {
            n = 0;
        }
        return n + 1;
    }

    private int getBagItemIndex(int n) {
        int n2 = -1;
        for (int i = 0; i < this.bagItemCount; ++i) {
            if (this.playerBagArray[i] != n) continue;
            n2 = i;
            break;
        }
        return n2;
    }

    private boolean changeEquipWeaponCloth(int newEquipIndex, boolean forceEquip) {
        boolean result = true;
        int currentIndex = 0;
        if (newEquipIndex < 6) {
            currentIndex = this.convertEquipIdToOrderArrayIndex((int)this.playerWeapon, 0, 6);
            if (currentIndex < newEquipIndex || forceEquip) {
                this.playerAttack -= this.equipPropertyLookupTable[currentIndex];
                this.playerAttack += this.equipPropertyLookupTable[newEquipIndex];
                this.playerWeapon = this.equipObjectIdLookupTable[newEquipIndex];
            } else {
                result = false;
            }
        } else {
            currentIndex = this.convertEquipIdToOrderArrayIndex((int)this.playerCloth, 6, 12);
            if (currentIndex < newEquipIndex || forceEquip) {
                this.playerAmaor -= this.equipPropertyLookupTable[currentIndex];
                this.playerAmaor += this.equipPropertyLookupTable[newEquipIndex];
                this.playerCloth = this.equipObjectIdLookupTable[newEquipIndex];
            } else {
                result = false;
            }
        }
        return result;
    }

    private int convertEquipIdToOrderArrayIndex(int n, int n2, int n3) {
        while (--n3 >= n2) {
            if (this.equipObjectIdLookupTable[n3] != n) continue;
            return n3;
        }
        return 0;
    }

    private static int itemTypeToUseCountOrder(int n) {
        int result = 0;
        switch (n) {
            case 85: {      //黄金钥匙
                result = 20;
                break;
            }
            case 86: {      //日月无极钹
                result = 21;
                break;
            }
            default: {
                result = n - 13;
            }
        }
        return result;
    }

    private void equipItem(int objectId) {
        int itemIndex = this.getBagItemIndex(objectId);
        int n3 = a.itemTypeToUseCountOrder(objectId);
        //如果物品不存在则入包
        if (itemIndex < 0) {
            //将物品入包
            this.playerBagArray[this.bagItemCount] = (byte)objectId;
            //增加属性
            this.itemCurrentUseContArray[this.bagItemCount] = this.var_byte_arr_q[n3];
            ++this.bagItemCount;
        } else {
            //已经在背包里了，加属性
            this.itemCurrentUseContArray[itemIndex] = this.itemCurrentUseContArray[itemIndex] + this.var_byte_arr_q[n3];
        }
        this.playerCurrentEquipItemId = (byte)objectId;
        this.a((byte)1, this.var_java_lang_String_arr_k[n3], (byte)0, (byte)3);
    }

    private boolean hasKey(byte by) {
        boolean bHasKey = false;
        switch (by) {
            case 26: {          //黄
                if (this.yellowKeyCount <= 0) break;
                this.a((byte)1, 2, this.playerPixelX, this.playerPixelY);
                --this.yellowKeyCount;
                bHasKey = true;
                break;
            }
            case 28: {          //蓝
                if (this.blueKeyCount <= 0) break;
                this.a((byte)1, 0, this.playerPixelX, this.playerPixelY);
                --this.blueKeyCount;
                bHasKey = true;
                break;
            }
            case 27: {          //红
                if (this.redKeyCount <= 0) break;
                this.a((byte)1, 1, this.playerPixelX, this.playerPixelY);
                --this.redKeyCount;
                bHasKey = true;
            }
        }
        return bHasKey;
    }

    private void l(int objectId) {
        if (this.itemCurrentUseContArray[objectId] > 0) {
            if (this.useBagItem(this.playerBagArray[objectId])) {
                this.itemCurrentUseContArray[objectId] = (byte)(this.itemCurrentUseContArray[objectId] - 1);
                if (this.itemCurrentUseContArray[objectId] == 0) {
                    int index = objectId;
                    while (index < this.bagItemCount - 1) {
                        this.playerBagArray[index] = this.playerBagArray[index + 1];
                        this.itemCurrentUseContArray[index] = this.itemCurrentUseContArray[index + 1];
                        ++index;
                    }
                    if (this.bagItemCount > 0) {
                        --this.bagItemCount;
                    }
                    return;
                }
            }
        } else {
            this.useBagItem(this.playerBagArray[objectId]);
        }
    }

    private boolean useBagItem(byte objectId) {
        int n = 0;
        switch (objectId) {
            case 13: {          //火眼金睛
                this.gameStateFlag = (byte)5;      //火眼金睛状态
                this.void_a();
                break;
            }
            case 14: {          //生死簿
                this.gameStateFlag = (byte)12;     //生死簿状态
                this.void_a();
                break;
            }
            case 15: {                          //筋斗云
                break;
            }
            case 16: {                          //芭蕉扇
                if (!this.hasObjectAround((byte)10)) {        //检查火
                    this.a((byte)0, "你必须面对三昧真火再使用它。", (byte)0, (byte)0);
                    break;
                }
                this.gameStateFlag = (byte)3;
                n = 1;
                break;
            }
            case 17: {                          //金勺子
                if (!this.hasObjectAround((byte)11)) {
                    this.a((byte)0, "你必须面对一堵墙使用", (byte)0, (byte)0);
                    break;
                }
                this.gameStateFlag = (byte)3;
                n = 1;
                break;
            }
            case 18: {                          //玄明石 打开所有墙
                objectId = (byte)this.levelActorCount;
                while ((objectId = (byte)(objectId - 1)) >= 0) {
                    if (this.objectIdLookupTable[objectId] != 11) continue;
                    this.void_e(objectId);
                }
                this.gameStateFlag = (byte)3;
                n = 1;
                break;
            }
            //恢复物品
            case 19: {                          ///千年月桂露
                n = (this.playerAttack + this.playerAmaor) * 74 / 10;
                this.updateHp(n);
                this.a((byte)0, "增加了" + n + "血量", (byte)0, (byte)0);
                n = 1;
                break;
            }
            case 20: {                          //相形变位
                if (this.level == 40) {
                    this.a((byte)0, "本层不能直接瞬移。", (byte)0, (byte)0);
                    break;
                }
                int n2 = this.m_mapWidth - 1 - this.playerXOffset;
                int n3 = this.m_mapHeight - 1 - this.playerYOffest;
                boolean bl = this.boolean_a(n2, n3);
                if (bl) {
                    this.void_a(n2, n3);
                    this.i((this.preferWidth - 32 >> 1) - this.playerPixelX, (this.perferHeight - 32 >> 1) - this.playerPixelY);
                    this.k();
                }
                if (bl) {
                    this.gameStateFlag = (byte)3;
                    n = 1;
                    break;
                }
                if (this.var_boolean_f) break;
                this.a((byte)0, "无法移动到该位置", (byte)0, (byte)0);
                break;
            }
            case 21: {          //上行符
                n = this.a(this.level + 1, false, false);
                this.pressedKeyCode = 0;
                this.gameStateFlag = (byte)3;
                break;
            }
            case 22: {          //下行符
                n = this.a(this.level - 1, true, false);
                this.pressedKeyCode = 0;
                this.gameStateFlag = (byte)3;
                break;
            }
            case 85: {          //黄金钥匙 开全部的黄门
                objectId = (byte)this.levelActorCount;
                while ((objectId = (byte)(objectId - 1)) >= 0) {
                    if (this.objectIdLookupTable[objectId] != 1) continue;
                    this.void_e(objectId);
                }
                this.gameStateFlag = (byte)3;
                n = 1;
                break;
            }
            case 86: {
                int x = this.playerPixelX >> 5;
                int y = this.playerPixelY >> 5;
                this.killMonsterDirectly(x, y - 1);
                this.killMonsterDirectly(x, y + 1);
                this.killMonsterDirectly(x - 1, y);
                this.killMonsterDirectly(x + 1, y);
                this.gameStateFlag = (byte)3;
                n = 1;
            }
        }
        return n != 0;
    }
    //判断周围一格内是否有指定物体
    private boolean hasObjectAround(byte objectId) {
        int n = this.playerPixelX >> 5;
        int n2 = this.playerPixelY >> 5;
        int n3 = this.int_b(n, n2 - 1, objectId);
        int n4 = this.int_b(n, n2 + 1, objectId);
        int n5 = this.int_b(n - 1, n2, objectId);
        objectId = (byte)this.int_b(n + 1, n2, objectId);
        n = 0;
        if (n3 >= 0) {
            this.void_e(n3);
            ++n;
        }
        if (n4 >= 0) {
            this.void_e(n4);
            ++n;
        }
        if (n5 >= 0) {
            this.void_e(n5);
            ++n;
        }
        if (objectId >= 0) {
            this.void_e(objectId);
            ++n;
        }
        return n > 0;
    }

    private void killMonsterDirectly(int n, int n2) {
        try {
            byte by = this.var_byte_arr_arr_c[n2][n];
            int n3 = this.var_byte_arr_k[by];
            int n4 = 0;
            int n5 = 0;
            n4 = 0;
            if (n3 > 0) {
                for (int i = 0; i < n3; ++i) {
                    n4 = this.var_byte_arr_arr_d[by][i] - 1;
                    n5 = this.objectIdLookupTable[n4];
                    if (n5 == 5) {      //门卫
                        n4 = this.npcTalkIndexLookupTable[n4];
                        this.void_b(n, n2, i);
                        if (!this.boolean_b(n4)) continue;
                        this.var_byte_l = (byte)4;
                        continue;
                    }
                    //如果是boss敌人或者不是怪物或特定属性不为1，跳过
                    if (n5 >= 67 || this.objectTypeLookupTable[n5] != 8 || this.var_byte_arr_e[n4] == 1)
                        continue;
                    this.void_e(n4);
                    if (this.getBagItemIndex(25) >= 0) {      //如果有幸运金币
                        this.addMoney(this.monsterMoneyLookupTable[n5 - 41] << 1, 0, 0);
                        continue;
                    }
                    this.addMoney(this.monsterMoneyLookupTable[n5 - 41], 0, 0);
                }
            }
            return;
        }
        catch (Exception exception) {
            Exception exception2 = exception;
            exception.printStackTrace();
            return;
        }
    }

    private void w() {
        int n;
        int n2;
        int n3;
        a a2;
        int n4;
        this.var_int_arr_w = null;
        this.var_int_arr_w = new int[128];
        this.var_byte_arr_u = null;
        this.var_byte_arr_u = new byte[128];
        this.be = 208;
        this.bb = 0;
        block0: for (int i = 0; i < this.levelActorCount; ++i) {
            if (this.var_boolean_arr_b[i] || this.objectTypeLookupTable[this.objectIdLookupTable[i]] != 8) continue;
            n4 = this.objectIdLookupTable[i];
            a2 = this;
            n3 = a2.bb;
            while (--n3 >= 0) {
                if (n4 != a2.var_byte_arr_u[n3]) continue;
                continue block0;
            }
            n3 = a2.var_int_arr_v[n4 - 41];
            n2 = a2.var_int_arr_t[n4 - 41];
            n = a2.var_int_arr_u[n4 - 41];
            a2.var_int_arr_w[a2.bb] = a.a(a2.int_f(n4), a2.var_int_L, n3, n2, n, true);
            a2.var_byte_arr_u[a2.bb] = n4;
            ++a2.bb;
        }
        a2 = this;
        n4 = 0;
        n3 = 0;
        for (n2 = 0; n2 < a2.bb; ++n2) {
            n = a2.bb;
            while (--n > n2) {
                if (a2.var_int_arr_w[n] < 0 || a2.var_int_arr_w[n] >= a2.var_int_arr_w[n - 1]) continue;
                n4 = a2.var_byte_arr_u[n];
                a2.var_byte_arr_u[n] = a2.var_byte_arr_u[n - 1];
                a2.var_byte_arr_u[n - 1] = n4;
                n3 = a2.var_int_arr_w[n];
                a2.var_int_arr_w[n] = a2.var_int_arr_w[n - 1];
                a2.var_int_arr_w[n - 1] = n3;
            }
        }
        this.bc = 258 / (this.var_int_b + 4 + 36);
        if (this.bc > this.bb) {
            this.bc = this.bb;
        }
        this.bd = (this.var_int_b + 4 + 36) * this.bc + 32;
        this.bf = 0;
        this.bg = this.bc;
        if (this.bg > this.bb) {
            this.bg = this.bb;
        }
    }

    private void m(int n) {
        int n2 = this.bb - this.bc;
        if (n2 < 0) {
            n2 = 0;
        }
        if (n >= 0 && n <= n2) {
            this.bf = n;
            this.bg = this.bf + this.bc;
            if (this.bg > this.bb) {
                this.bg = this.bb;
            }
        }
    }

    private void a(int n, int n2, byte by) {
        this.var_javax_microedition_lcdui_Graphics_a.fillTriangle(n, n2 - 6, n, n2 + 6, n - 6, n2);
    }

    private boolean boolean_d(int n) {
        this.var_boolean_B = false;
        this.gameStateFlag = (byte)11;
        this.bh = n;
        this.bi = 0;
        this.int_e(0);
        this.var_byte_q = 0;
        this.var_java_lang_String_f = this.var_java_lang_String_arr_n[this.bh];
        this.var_java_lang_String_c = null;
        this.bm = 0;
        switch (n) {
            case 31: {
                this.r(this.level);
                this.loadLevelSprites(24);
                n = this.levelActorCount;
                while (--n >= 0) {
                    if (this.objectIdLookupTable[n] != 4) continue;
                    this.var_boolean_arr_b[n] = true;
                }
                this.r(24);
                this.s();
                this.loadLevelSprites(this.level);
            }
        }
        return false;
    }

    private boolean b(int n, boolean bl) {
        if (n >= this.bj) {
            return false;
        }
        boolean bl2 = !this.var_boolean_arr_g[n];
        int n2 = 0;
        switch (n) {
            case 0: {
                if (!bl2) break;
                this.var_boolean_arr_g[19] = true;
                break;
            }
            case 1: {
                bl2 &= this.var_boolean_arr_g[0] & !bl;
                break;
            }
            case 2: {
                bl2 &= this.var_boolean_arr_g[1] & !bl;
                break;
            }
            case 3: {
                bl2 &= bl;
                break;
            }
            case 4: {
                bl2 &= this.var_boolean_arr_g[3] & bl;
                break;
            }
            case 7: {
                if (!(bl2 &= bl && !this.boolean_d(23, 12))) break;
                this.var_boolean_arr_g[32] = true;
                break;
            }
            case 8:
            case 9:
            case 11:
            case 12:
            case 19:
            case 30:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 48:
            case 49:
            case 50:
            case 52:
            case 53:
            case 55:
            case 56: {
                bl2 &= bl;
                break;
            }
            case 46: {
                bl2 &= bl & !this.var_boolean_arr_g[47];
                break;
            }
            case 47: {
                bl2 &= bl & !this.var_boolean_arr_g[46];
                break;
            }
            case 13: {
                break;
            }
            case 15: {
                if (this.boolean_d(this.level, 5)) {
                    bl2 = false;
                    break;
                }
                bl2 &= bl;
                break;
            }
            case 18: {
                if (!(bl2 &= bl) || this.int_b(2, 2, 1) >= 0 && this.int_b(2, 4, 1) >= 0 && this.int_b(2, 6, 1) >= 0 && this.int_b(6, 2, 1) >= 0 && this.int_b(4, 6, 1) >= 0 && this.int_b(6, 6, 1) >= 0 && this.int_b(4, 2, 1) < 0 && this.int_b(6, 4, 1) < 0) break;
                bl2 = false;
                this.var_boolean_arr_g[18] = true;
                break;
            }
            case 25: {
                bl2 &= bl & this.var_boolean_arr_g[13] & this.int_b(2, 2, 60) < 0 & this.int_b(10, 2, 60) < 0;
                break;
            }
            case 26: {
                if (this.int_b(11, 4, 84) >= 0) break;
                bl2 = false;
                break;
            }
            case 31: {
                bl2 &= bl;
                bl2 &= this.getBagItemIndex(16) >= 0;
                break;
            }
            case 32: {
                if (this.var_boolean_arr_g[7]) {
                    bl2 = false;
                    break;
                }
                bl2 &= !bl & this.boolean_d(23, 12);
                break;
            }
            case 33: {
                bl2 &= this.var_boolean_arr_g[7];
                break;
            }
            case 34: {
                if (!(bl2 &= bl & !this.var_boolean_arr_g[10])) break;
                n2 = this.caculateHpReduce(69, true);
                bl2 &= n2 < 0 || n2 >= this.playerHp;
                break;
            }
            case 24: {
                if (!(bl2 &= !bl)) break;
                bl2 = true & 0 < this.playerHp;
                break;
            }
            case 16: {
                bl2 &= this.var_byte_A == 0;
                break;
            }
            case 66: {
                bl2 = false;
                break;
            }
            case 67: {
                bl2 &= this.var_byte_A > 0;
                break;
            }
            case 27: {
                bl2 &= bl & this.var_boolean_arr_g[0];
            }
        }
        return bl2;
    }

    private void n(int n) {
        byte by = 0;
        if (n <= this.br) {
            this.bi = n;
            this.var_byte_r = this.bi < 0 ? (byte)-1 : this.var_byte_arr_v[this.bi];
            this.bp = this.int_e(this.var_byte_r);
            by = this.var_byte_r;
            if (by < 0) {
                this.var_java_lang_String_d = this.var_java_lang_String_c = "?: \\cF8F8F8" + this.var_java_lang_String_arr_o[this.bi];
                this.var_int_H = 11;
            } else {
                this.var_java_lang_String_d = this.var_java_lang_String_c = this.var_java_lang_String_arr_m[by] + ": \\cF8F8F8" + this.var_java_lang_String_arr_o[this.bi];
                this.var_int_H = this.var_java_lang_String_arr_m[by].length() + 10;
            }
            this.a(this.var_java_lang_String_c, 129, (this.var_int_I << 1) + 12, this.var_int_H);
            return;
        }
        this.var_byte_q = 0;
        this.var_int_H = 0;
    }

    private boolean boolean_a() {
        return this.bt == this.bv && this.bu == this.bw;
    }

    private void a(String object, int n) {
        Object var3_3 = null;
        boolean bl = false;
        bl = false;
        int n2 = 0;
        int n3 = 0;
        int n4 = 0;
        if (n + 3 <= ((String)object).length()) {
            String string = ((String)object).substring(n, n + 3);
            n += 3;
            if (string.equals("TAK")) {
                this.bq = this.a((String)object, n + 1, "_");
                n = this.bs;
                this.br = this.a((String)object, n + 1, " ");
                this.bm = this.bs + 1;
                this.var_byte_q = 1;
                this.n(this.bq);
            } else if (string.equals("MOV")) {
                int n5 = this.a((String)object, n + 1, "_");
                n = this.bs;
                if (n5 > 0) {
                    n3 = this.a((String)object, n + 1, "_");
                    n = this.bs;
                    n4 = this.a((String)object, n + 1, "_");
                    n = this.bs;
                }
                this.bk = this.a((String)object, n + 1, "_");
                n = this.bs;
                this.bl = this.a((String)object, n + 1, " ");
                this.bm = this.bs + 1;
                if (n5 > 0) {
                    this.bx = this.int_b(n3, n4, n5);
                    if (this.bx >= 0) {
                        this.var_byte_s = 0;
                        object = this;
                        if (((a)object).objectIdLookupTable[((a)object).bx] == 72) {
                            object.var_int_arr_m[object.bx] = 1;
                        }
                        ((a)object).bz = ((a)object).mapObjectPixelX[((a)object).bx] >> 5;
                        ((a)object).bA = ((a)object).mapObjectPixelY[((a)object).bx] >> 5;
                        this.boolean_a(((a)object).bz, ((a)object).bA, ((a)object).bk, ((a)object).bl);
                        this.var_byte_q = (byte)2;
                    } else {
                        this.a(this.var_java_lang_String_f, this.bm);
                    }
                } else if (this.boolean_a(this.playerXOffset, this.playerYOffest, this.bk, this.bl)) {
                    this.var_boolean_B = true;
                    this.var_byte_q = (byte)3;
                    this.var_byte_l = 0;
                    this.int_e(0);
                }
            } else if (string.equals("GUT")) {
                n2 = this.a((String)object, n + 1, " ");
                this.var_boolean_arr_g[this.bh] = true;
                this.boolean_d(n2);
            } else if (string.equals("DES")) {
                int n6 = this.a((String)object, n + 1, "_");
                n = this.bs;
                if (n6 < 0) {
                    this.a((String)object, n + 1, " ");
                    n2 = -n6;
                    object = this;
                    n6 = ((a)object).levelActorCount;
                    while (--n6 >= 0) {
                        if (((a)object).objectIdLookupTable[n6] != n2) continue;
                        this.void_e(n6);
                    }
                } else {
                    n3 = this.a((String)object, n + 1, "_");
                    n6 = this.int_b(n3, n4 = this.a((String)object, (n = this.bs) + 1, " "), n6);
                    if (n6 >= 0) {
                        this.void_e(n6);
                    }
                }
                this.bm = this.bs + 1;
            } else if (string.equals("SWD")) {
                object = this;
                int n7 = ((a)object).levelActorCount;
                while (--n7 >= 0) {
                    if (((a)object).var_boolean_arr_b[n7] || (n2 = ((a)object).objectIdLookupTable[n7]) != 81) continue;
                    object.var_boolean_arr_a[n7] = true;
                    object.objectIdLookupTable[n7] = 4;
                    this.initSpriteWidthHeight(4, n7);
                    object.var_byte_arr_e[n7] = 2;
                    object.var_int_arr_m[n7] = 8;
                }
                this.bm = n + 1;
            } else if (string.equals("MVS")) {
                int n8;
                object = this;
                this.var_short_arr_e = null;
                ((a)object).var_short_arr_e = new short[32];
                n2 = 0;
                int n9 = 0;
                n3 = 0;
                n4 = ((a)object).levelActorCount;
                block22: while (--n4 >= 0) {
                    n2 = ((a)object).objectIdLookupTable[n4];
                    if (n2 != 82) continue;
                    n9 = ((a)object).npcTalkIndexLookupTable[n4] & 0xFF;
                    for (n8 = 0; n8 < 32; n8 += 2) {
                        n3 = ((a)object).var_short_arr_e[n8] - 1;
                        if (n3 > 0) {
                            if (n9 != (((a)object).npcTalkIndexLookupTable[n3] & 0xFF)) continue;
                            object.var_short_arr_e[n8 + 1] = n4 + 1;
                            continue block22;
                        }
                        object.var_short_arr_e[n8] = n4 + 1;
                        continue block22;
                    }
                }
                for (int i = 0; i < 32; i += 2) {
                    int n10;
                    int n11;
                    n3 = ((a)object).var_short_arr_e[i];
                    int n12 = ((a)object).var_short_arr_e[i + 1];
                    if (n3 <= 0) break;
                    if (n12 <= 0) continue;
                    --n12;
                    n8 = ((a)object).mapObjectPixelX[--n3] >> 5;
                    n4 = ((a)object).mapObjectPixelY[n3] >> 5;
                    n9 = ((a)object).var_byte_arr_arr_c[n4][n8];
                    int n13 = ((a)object).var_byte_arr_k[n9];
                    for (n11 = 0; n11 < n13; ++n11) {
                        n10 = ((a)object).var_byte_arr_arr_d[n9][n11] - 1;
                        n2 = ((a)object).objectIdLookupTable[n10];
                        if (((a)object).objectTypeLookupTable[n2] != 8) continue;
                        this.void_a(((a)object).mapObjectPixelX[n12] >> 5, ((a)object).mapObjectPixelY[n12] >> 5, 82);
                        this.void_a(n8, n4, 82);
                        this.e(n10, ((a)object).mapObjectPixelX[n12] >> 5, ((a)object).mapObjectPixelY[n12] >> 5);
                    }
                    n9 = n3;
                    n3 = n12;
                    n12 = n9;
                    n8 = ((a)object).mapObjectPixelX[n3] >> 5;
                    n4 = ((a)object).mapObjectPixelY[n3] >> 5;
                    n9 = ((a)object).var_byte_arr_arr_c[n4][n8];
                    n13 = ((a)object).var_byte_arr_k[n9];
                    for (n11 = 0; n11 < n13; ++n11) {
                        n10 = ((a)object).var_byte_arr_arr_d[n9][n11] - 1;
                        n2 = ((a)object).objectIdLookupTable[n10];
                        if (((a)object).objectTypeLookupTable[n2] != 8) continue;
                        this.void_a(((a)object).mapObjectPixelX[n12] >> 5, ((a)object).mapObjectPixelY[n12] >> 5, 82);
                        this.void_a(n8, n4, 82);
                        this.e(n10, ((a)object).mapObjectPixelX[n12] >> 5, ((a)object).mapObjectPixelY[n12] >> 5);
                    }
                }
                this.bm = n + 1;
            } else if (string.equals("LAY")) {
                this.r(this.level);
                this.var_byte_x = (byte)this.a((String)object, n + 1, " ");
                this.bm = this.bs + 1;
                this.var_boolean_q = true;
                this.var_java_lang_String_c = null;
                this.var_byte_q = (byte)5;
            } else if (string.equals("ROS")) {
                n2 = this.a((String)object, n + 1, "_");
                n = this.bs;
                switch (n2) {
                    case 1: {
                        this.playerPixelX = this.a((String)object, n + 1, "_") << 5;
                        n = this.bs;
                        this.playerPixelY = this.a((String)object, n + 1, " ") << 5;
                        this.int_e(0);
                        break;
                    }
                    case 2: {
                        this.changeEquipWeaponCloth(this.a((String)object, n + 1, " "), true);
                        break;
                    }
                    case 3: {
                        this.playerHp = this.a((String)object, n + 1, " ");
                        break;
                    }
                    case 4: {
                        this.var_byte_m = (byte)this.a((String)object, n + 1, " ");
                        break;
                    }
                    case 5: {
                        this.playerAttack = this.a((String)object, n + 1, " ");
                        break;
                    }
                    case 6: {
                        this.playerAmaor = this.a((String)object, n + 1, " ");
                    }
                }
                this.bm = this.bs + 1;
            } else if (string.equals("CES")) {
                int n14;
                int n15 = this.a((String)object, n + 1, "_");
                n = this.bs;
                n3 = this.a((String)object, n + 1, "_");
                n = this.bs;
                n4 = this.a((String)object, n + 1, " ");
                n2 = this.loadSpritePropertyInternal(n15, n3 << 5, n4 << 5, 0);
                this.void_d(n2);
                object = this;
                this.bt = (((a)object).preferWidth - 32 >> 1) - ((a)object).ae;
                ((a)object).bu = (((a)object).perferHeight - 32 >> 1) - ((a)object).af;
                if (n2 >= 0) {
                    ((a)object).bv = ((a)object).mapObjectPixelX[n2];
                    ((a)object).bw = ((a)object).mapObjectPixelY[n2];
                }
                n2 = n15;
                object = this;
                switch (((a)object).objectTypeLookupTable[n2]) {
                    case 1:
                    case 8:
                    case 16: {
                        n14 = 5;
                        break;
                    }
                    case 2:
                    case 4: {
                        n14 = 8;
                        break;
                    }
                    default: {
                        n14 = 0;
                    }
                }
                this.bo = n14;
                this.bm = this.bs + 1;
            } else if (string.equals("GIN")) {
                n2 = this.a((String)object, n + 1, "_");
                n = this.bs;
                int n16 = this.a((String)object, n + 1, " ");
                switch (n2) {
                    case 0: {
                        this.pickupGroundItem(n16);
                        break;
                    }
                    case 1: {
                        this.addMoney(n16, this.playerPixelX, this.playerPixelY);
                    }
                }
                this.bm = this.bs + 1;
                this.a(this.var_java_lang_String_f, this.bm);
            } else if (string.equals("ADD")) {
                n2 = this.a((String)object, n + 1, "_");
                n = this.bs;
                int n17 = this.a((String)object, n + 1, "_");
                n = this.bs;
                n3 = this.a((String)object, n + 1, "_");
                n = this.bs;
                n4 = this.a((String)object, n + 1, " ");
                boolean bl2 = false;
                n4 <<= 5;
                n3 <<= 5;
                object = this;
                if (((a)object).level != n2) {
                    this.r(((a)object).level);
                    this.loadLevelSprites(n2);
                }
                this.loadSpritePropertyInternal(n17, n3, n4, 0);
                this.r(n2);
                if (((a)object).level != n2) {
                    this.s();
                    this.loadLevelSprites(((a)object).level);
                }
                this.bm = this.bs + 1;
            } else if (string.equals("GLV")) {
                this.a((String)object, n + 1, " ");
                this.bm = this.bs + 1;
            } else if (string.equals("RES")) {
                this.a((String)object, n + 1, " ");
                if (this.var_byte_A == 0) {
                    object = this;
                    ((a)object).blueKeyCount = 0;
                    ((a)object).redKeyCount = 0;
                    this.yellowKeyCount = 0;
                    ((a)object).bagItemCount = 0;
                    ((a)object).aQ = 4;
                    ((a)object).ar = 0;
                    ((a)object).an = 1;
                    ((a)object).ao = 3;
                    ((a)object).playerAttack = 10;
                    ((a)object).playerAmaor = 10;
                    ((a)object).playerHp = 400;
                    ((a)object).aL = 0;
                }
                this.bm = this.bs + 1;
            } else if (string.equals("SEE")) {
                this.bk = this.a((String)object, n + 1, "_");
                n = this.bs;
                this.bl = this.a((String)object, n + 1, "_");
                n = this.bs;
                this.bq = this.a((String)object, n + 1, "_");
                n = this.bs;
                this.br = this.a((String)object, n + 1, "_");
                n = this.bs;
                this.bn = this.a((String)object, n + 1, " ");
                this.bm = this.bs + 1;
                this.n(this.bq);
                switch (this.bn) {
                    case 0: {
                        break;
                    }
                    case 1: {
                        if (!this.boolean_a(this.playerXOffset, this.playerYOffest, this.bk, this.bl)) break;
                        this.var_boolean_A = true;
                        this.var_byte_l = 0;
                    }
                }
                this.var_byte_q = (byte)6;
                this.l(this.bk, this.bl);
            } else if (string.equals("END")) {
                this.a((String)object, n + 1, " ");
                this.gameStateFlag = (byte)20;
                this.void_a();
                this.bm = this.bs + 1;
            } else if (string.equals("SMS")) {
                this.a((String)object, n + 1, " ");
                this.bm = this.bs + 1;
            }
            if (this.bm < this.var_java_lang_String_f.length()) {
                return;
            }
        } else {
            this.var_byte_q = (byte)4;
            if (this.bh != 32) {
                this.var_boolean_arr_g[this.bh] = true;
            }
            this.int_e(0);
        }
    }

    private int a(String string, int n, String string2) {
        int n2 = 0;
        n2 = string.indexOf(string2, n);
        string = string.substring(n, n2);
        this.bs = n2;
        n2 = Integer.parseInt(string);
        return n2;
    }

    private int int_b(int n, int n2, int n3) {
        n = this.var_byte_arr_arr_c[n2][n];
        n2 = this.var_byte_arr_k[n];
        int n4 = 0;
        if (n2 > 0) {
            for (int i = 0; i < n2; ++i) {
                n4 = this.var_byte_arr_arr_d[n][i] - 1;
                if (this.objectIdLookupTable[n4] != n3 || this.var_byte_arr_e[n4] == 1) continue;
                return n4;
            }
        }
        return -1;
    }

    private void d(int n, int n2, int n3) {
        if (this.boolean_b(n, --n2) && !this.boolean_c(n, n2) && (n != this.playerXOffset || n2 != this.playerYOffest)) {
            this.void_f(n3);
            n3 = this.loadSpritePropertyInternal(60, n << 5, n2 << 5, 0);
            this.void_d(n3);
        }
    }

    private boolean boolean_d(int n, int n2) {
        boolean bl = false;
        if (this.level != n) {
            this.r(this.level);
            this.loadLevelSprites(n);
        }
        for (int i = 0; i < this.levelActorCount; ++i) {
            if (this.var_boolean_arr_b[i] || this.objectIdLookupTable[i] != n2) continue;
            bl = true;
            break;
        }
        if (this.level != n) {
            this.s();
            this.loadLevelSprites(this.level);
        }
        return bl;
    }

    private void l(int n, int n2) {
        this.bt = (this.preferWidth - 32 >> 1) - this.ae;
        this.bu = (this.perferHeight - 32 >> 1) - this.af;
        this.bv = n << 5;
        this.bw = n2 << 5;
    }

    private int int_e(int n) {
        int n2;
        int n3;
        block4: {
            this.bt = (this.preferWidth - 32 >> 1) - this.ae;
            this.bu = (this.perferHeight - 32 >> 1) - this.af;
            if (n == 0 || n == 87) {
                this.bv = this.playerPixelX;
                this.bw = this.playerPixelY;
                return -1;
            }
            int n4 = n;
            a a2 = this;
            int n5 = a2.var_int_T;
            while (--n5 >= 0) {
                if (a2.objectIdLookupTable[n5] != n4) continue;
                n3 = n5;
                break block4;
            }
            n3 = n2 = -1;
        }
        if (n3 >= 0) {
            this.bv = this.mapObjectPixelX[n2];
            this.bw = this.mapObjectPixelY[n2];
        }
        if (n == 69) {
            this.bv += 32;
        }
        return n2;
    }

    private void x() {
        if (this.bt < this.bv) {
            this.bt += (this.bv - this.bt >> 2) + 2;
            if (this.bt > this.bv) {
                this.bt = this.bv;
            }
        } else if (this.bt > this.bv) {
            this.bt += (this.bv - this.bt >> 2) - 2;
            if (this.bt < this.bv) {
                this.bt = this.bv;
            }
        }
        if (this.bu < this.bw) {
            this.bu += (this.bw - this.bu >> 2) + 2;
            if (this.bu > this.bw) {
                this.bu = this.bw;
            }
        } else if (this.bu > this.bw) {
            this.bu += (this.bw - this.bu >> 2) - 2;
            if (this.bu < this.bw) {
                this.bu = this.bw;
            }
        }
        this.i((this.preferWidth - 32 >> 1) - this.bt, (this.perferHeight - 32 >> 1) - this.bu);
    }

    private void y() {
        switch (this.var_byte_s) {
            case 5: {
                this.c(this.var_boolean_o);
                if (this.var_boolean_x || !this.var_boolean_arr_b[this.bx] && this.var_byte_arr_e[this.bx] != 1) break;
                this.var_byte_q = 0;
                this.var_byte_s = 0;
                this.bx = -1;
                return;
            }
            case 0: {
                if (this.bS > 0) {
                    this.var_byte_t = this.var_byte_arr_Q[--this.bS];
                    a a2 = this;
                    int n = 0;
                    int n2 = 0;
                    int n3 = 0;
                    int n4 = 0;
                    n = a2.var_int_arr_g[a2.bx] >> 5;
                    n2 = a2.var_int_arr_h[a2.bx] >> 5;
                    switch (a2.var_byte_t) {
                        case 1: {
                            --n2;
                            break;
                        }
                        case 0: {
                            ++n2;
                            break;
                        }
                        case 3: {
                            --n;
                            break;
                        }
                        case 2: {
                            ++n;
                        }
                    }
                    a2.var_byte_s = 1;
                    if (a2.objectIdLookupTable[a2.bx] != 72 && n == a2.var_int_P && n2 == a2.var_int_Q) {
                        n3 = a2.objectIdLookupTable[a2.bx];
                        n4 = a2.int_a(n3, false);
                        if (n4 >= 0 && n4 < a2.var_int_J) {
                            a2.bU = a2.var_int_arr_v[n3 - 41];
                            a2.var_byte_l = (byte)5;
                            a2.var_boolean_o = false;
                            a2.var_int_S = a2.bx;
                            a2.var_byte_arr_e[a2.bx] = 5;
                            a2.var_byte_s = (byte)5;
                            a2.var_boolean_z = false;
                            n4 = a2.var_int_arr_t[n3 - 41] - a2.var_int_L;
                            if (n4 > 0) {
                                a2.var_int_J -= n4;
                            }
                        } else {
                            a2.var_byte_l = 1;
                            a2.var_byte_m = a2.var_byte_t;
                        }
                    }
                    if (a2.var_byte_arr_k[n = a2.var_byte_arr_arr_c[n2][n]] > 0) {
                        n4 = a2.var_byte_arr_k[n];
                        while (--n4 >= 0) {
                            n2 = a2.var_byte_arr_arr_d[n][n4] - 1;
                            n3 = a2.objectIdLookupTable[n2];
                            switch (a2.var_byte_arr_d[n3]) {
                                case 1: {
                                    switch (n3) {
                                        case 11: {
                                            a2.void_e(n2);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    return;
                }
                this.f(this.bx, this.bz, this.bA);
                this.var_byte_q = 0;
                this.initSpriteProperty(this.objectIdLookupTable[this.bx], this.bx);
                this.bx = -1;
                return;
            }
            case 1: {
                switch (this.var_byte_t) {
                    case 1: {
                        int n = this.bx;
                        this.mapObjectPixelY[n] = this.mapObjectPixelY[n] - 8;
                        break;
                    }
                    case 0: {
                        int n = this.bx;
                        this.mapObjectPixelY[n] = this.mapObjectPixelY[n] + 8;
                        break;
                    }
                    case 3: {
                        int n = this.bx;
                        this.mapObjectPixelX[n] = this.mapObjectPixelX[n] - 8;
                        break;
                    }
                    case 2: {
                        int n = this.bx;
                        this.mapObjectPixelX[n] = this.mapObjectPixelX[n] + 8;
                    }
                }
                this.bv = this.mapObjectPixelX[this.bx];
                this.bw = this.mapObjectPixelY[this.bx];
                this.by += 8;
                int n = this.var_int_arr_m[this.bx];
                if (n > 0) {
                    if (this.var_int_arr_k[this.bx] < this.var_int_arr_arr_c[n].length - 1) {
                        int n5 = this.bx;
                        this.var_int_arr_k[n5] = this.var_int_arr_k[n5] + 1;
                    } else {
                        this.var_int_arr_k[this.bx] = 0;
                    }
                }
                if (this.by != 32) break;
                this.by = 0;
                this.var_byte_s = 0;
                a a3 = this;
                int n6 = a3.var_int_arr_g[a3.bx] >> 5;
                int n7 = a3.var_int_arr_h[a3.bx] >> 5;
                int n8 = 0;
                if (n6 == a3.var_int_P && n7 == a3.var_int_Q && a3.objectIdLookupTable[a3.bx] != 72) {
                    n8 = a3.int_a(a3.objectIdLookupTable[a3.bx], false);
                    if (n8 < 0 || n8 >= a3.var_int_J) {
                        a3.var_boolean_B = false;
                        a3.var_byte_a = (byte)3;
                        a3.var_byte_l = 1;
                        a3.var_byte_m = a3.var_byte_t;
                    } else {
                        a3.var_int_J -= n8;
                        a3.f(a3.bx, a3.bz, a3.bA);
                        a3.void_a(n6, n7, a3.objectIdLookupTable[a3.bx]);
                    }
                }
                this.y();
            }
        }
    }

    private void e(int n, int n2, int n3) {
        int n4 = this.mapObjectPixelX[n];
        int n5 = this.mapObjectPixelY[n];
        short s = this.npcTalkIndexLookupTable[n];
        this.loadSpritePropertyInternal(this.objectIdLookupTable[n], n2 << 5, n3 << 5, (int)s);
        this.void_a(n4 >> 5, n5 >> 5, this.objectIdLookupTable[n]);
    }

    private void f(int n, int n2, int n3) {
        int n4;
        int n5;
        n2 = this.var_byte_arr_arr_c[n3][n2];
        n3 = this.var_byte_arr_k[n2];
        for (n5 = 0; n5 < n3; ++n5) {
            if (this.var_byte_arr_arr_d[n2][n5] - 1 != n) continue;
            for (n4 = n5; n4 < n3 - 1; ++n4) {
                this.var_byte_arr_arr_d[n2][n4] = this.var_byte_arr_arr_d[n2][n4 + 1];
            }
            int n6 = n2;
            this.var_byte_arr_k[n6] = this.var_byte_arr_k[n6] - 1;
            break;
        }
        if ((n2 = this.var_byte_arr_arr_c[n4 = this.mapObjectPixelY[n] >> 5][n5 = this.mapObjectPixelX[n] >> 5]) == 0) {
            this.var_byte_arr_arr_c[n4][n5] = this.var_byte_p = (byte)(this.var_byte_p + 1);
            n2 = this.var_byte_p;
        }
        this.var_byte_arr_arr_d[n2][this.var_byte_arr_k[n2]] = n + 1;
        int n7 = n2;
        this.var_byte_arr_k[n7] = this.var_byte_arr_k[n7] + 1;
    }

    private void o(int n) {
        byte[] byArray = this.var_byte_arr_arr_e[n];
        int n2 = byArray.length;
        int n3 = 0;
        for (int i = 0; i < n2; i += 4) {
            n3 = this.loadSpritePropertyInternal((int)byArray[i], byArray[i + 1] << 5, byArray[i + 2] << 5, (int)byArray[i + 3]);
            this.void_d(n3);
        }
    }

    private void z() {
        String string = "SKY_WAR";
        boolean bl = false;
        try {
            int n;
            this.var_javax_microedition_rms_RecordStore_a = RecordStore.openRecordStore((String)string, (boolean)true);
            if (this.var_javax_microedition_rms_RecordStore_a.getNumRecords() == 0) {
                bl = true;
            }
            this.var_java_io_ByteArrayOutputStream_a = new ByteArrayOutputStream();
            this.var_java_io_DataOutputStream_a = new DataOutputStream(this.var_java_io_ByteArrayOutputStream_a);
            for (n = 0; n < 4; ++n) {
                this.var_java_io_DataOutputStream_a.writeBoolean(this.var_boolean_arr_f[n]);
            }
            this.var_java_io_DataOutputStream_a.writeByte(this.var_int_arr_I.length);
            for (n = 0; n < this.var_int_arr_I.length; ++n) {
                this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_J[n]);
            }
            this.var_java_io_DataOutputStream_a.writeInt(this.bW);
            this.var_java_io_DataOutputStream_a.writeInt(this.bX);
            this.var_java_io_DataOutputStream_a.writeInt(this.bY);
            if (!bl) {
                this.var_javax_microedition_rms_RecordStore_a.setRecord(1, this.var_java_io_ByteArrayOutputStream_a.toByteArray(), 0, this.var_java_io_ByteArrayOutputStream_a.size());
                return;
            }
            this.var_javax_microedition_rms_RecordStore_a.addRecord(this.var_java_io_ByteArrayOutputStream_a.toByteArray(), 0, this.var_java_io_ByteArrayOutputStream_a.size());
        }
        catch (Exception exception) {}
    }

    private void A() {
        String string = "MOT_IF";
        if (!this.var_boolean_p) {
            this.var_boolean_arr_h = new boolean[6];
            this.var_byte_arr_y = new byte[6];
            this.var_int_arr_x = new int[6];
            this.var_int_arr_y = new int[6];
            this.var_int_arr_z = new int[6];
            this.var_int_arr_A = new int[6];
            this.var_int_arr_B = new int[6];
            this.var_int_arr_C = new int[6];
            this.var_int_arr_D = new int[6];
            this.var_byte_arr_z = new byte[6];
            this.var_byte_arr_A = new byte[6];
            this.var_boolean_p = true;
        }
        try {
            this.var_javax_microedition_rms_RecordStore_a = RecordStore.openRecordStore((String)string, (boolean)false);
            this.var_javax_microedition_rms_RecordEnumeration_a = this.var_javax_microedition_rms_RecordStore_a.enumerateRecords(null, null, false);
            int n = this.var_javax_microedition_rms_RecordEnumeration_a.nextRecordId();
            this.var_byte_arr_B = this.var_javax_microedition_rms_RecordStore_a.getRecord(n);
            this.var_java_io_DataInputStream_a = new DataInputStream(new ByteArrayInputStream(this.var_byte_arr_B));
            for (n = 0; n < 6; ++n) {
                boolean bl = this.var_boolean_arr_h[n] = this.var_java_io_DataInputStream_a.readByte() != 0;
                if (!this.var_boolean_arr_h[n]) continue;
                this.var_byte_arr_y[n] = this.var_java_io_DataInputStream_a.readByte();
                this.var_byte_arr_z[n] = this.var_java_io_DataInputStream_a.readByte();
                this.var_byte_arr_A[n] = this.var_java_io_DataInputStream_a.readByte();
                this.var_int_arr_x[n] = this.var_java_io_DataInputStream_a.readInt();
                this.var_int_arr_y[n] = this.var_java_io_DataInputStream_a.readInt();
                this.var_int_arr_z[n] = this.var_java_io_DataInputStream_a.readInt();
                this.var_int_arr_A[n] = this.var_java_io_DataInputStream_a.readInt();
                this.var_int_arr_B[n] = this.var_java_io_DataInputStream_a.readInt();
                this.var_int_arr_C[n] = this.var_java_io_DataInputStream_a.readInt();
                this.var_int_arr_D[n] = this.var_java_io_DataInputStream_a.readInt();
            }
            return;
        }
        catch (Exception exception) {
            this.p(-1);
            return;
        }
        finally {
            this.B();
        }
    }

    private void p(int n) {
        if (!this.var_boolean_p) {
            this.A();
        }
        if (n >= 0 && n < 6) {
            this.var_boolean_arr_h[n] = true;
            this.var_byte_arr_y[n] = this.level;
            this.var_int_arr_x[n] = this.playerHp;
            this.var_int_arr_y[n] = this.playerAttack;
            this.var_int_arr_z[n] = this.playerAmaor;
            this.var_int_arr_A[n] = this.yellowKeyCount;
            this.var_int_arr_B[n] = this.blueKeyCount;
            this.var_int_arr_C[n] = this.redKeyCount;
            this.var_int_arr_D[n] = this.aQ;
            this.var_byte_arr_z[n] = this.playerWeapon;
            this.var_byte_arr_A[n] = this.playerCloth;
        }
        Object object = "MOT_IF";
        a.void_a("MOT_IF");
        try {
            this.var_javax_microedition_rms_RecordStore_a = RecordStore.openRecordStore((String)object, (boolean)true);
            this.var_java_io_ByteArrayOutputStream_a = new ByteArrayOutputStream();
            this.var_java_io_DataOutputStream_a = new DataOutputStream(this.var_java_io_ByteArrayOutputStream_a);
            for (int i = 0; i < 6; ++i) {
                if (this.var_boolean_arr_h[i]) {
                    this.var_java_io_DataOutputStream_a.write(1);
                    this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_arr_y[i]);
                    this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_arr_z[i]);
                    this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_arr_A[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_x[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_y[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_z[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_A[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_B[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_C[i]);
                    this.var_java_io_DataOutputStream_a.writeInt(this.var_int_arr_D[i]);
                    continue;
                }
                this.var_java_io_DataOutputStream_a.write(0);
            }
            this.var_javax_microedition_rms_RecordStore_a.addRecord(this.var_java_io_ByteArrayOutputStream_a.toByteArray(), 0, this.var_java_io_ByteArrayOutputStream_a.size());
            return;
        }
        catch (Exception exception) {
            object = exception;
            exception.printStackTrace();
            return;
        }
        finally {
            this.B();
        }
    }

    private void b(boolean n) {
        n = n != 0 ? 2 : 1;
        int n2 = 240 - this.bF - 22 >> 1;
        int n3 = 320 - this.bB >> 1;
        Image image = null;
        this.a(n, n2, n3, this.bF + 22, this.bB);
        n3 += 16;
        n = this.bC;
        while (n < this.bD) {
            if (n != this.bE) {
                this.var_javax_microedition_lcdui_Graphics_a.setColor(7574946);
            } else {
                this.var_javax_microedition_lcdui_Graphics_a.setColor(3156024);
                this.var_javax_microedition_lcdui_Graphics_a.fillRect(120 - (this.bF >> 1), n3, this.bF, this.var_int_b + 4);
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][14], 120 - (this.bF >> 1) + 10, n3 + (this.var_int_b - 8 >> 1), 0);
                this.void_a(this.gamePngImagesGroups[8][14], 120 + (this.bF >> 1) - 30, n3 + (this.var_int_b - 8 >> 1), 1);
                this.var_javax_microedition_lcdui_Graphics_a.setColor(16377897);
            }
            if (!this.var_boolean_arr_h[n]) {
                this.var_javax_microedition_lcdui_Graphics_a.drawString("---", 120, n3 + 2, 17);
            } else {
                this.var_javax_microedition_lcdui_Graphics_a.drawString("存档" + n, 120, n3 + 2, 17);
            }
            ++n;
            n3 += this.var_int_b + 4;
        }
        n2 = 120 + ((this.bF >> 1) - 10);
        if (this.bC > 0) {
            this.a(this.gamePngImagesGroups[8][15], n2, n3 - 20, 0, 0, 7, 9);
        }
        if (this.bD < 6) {
            this.a(this.gamePngImagesGroups[8][15], n2, n3 - 10, 7, 0, 7, 9);
        }
        this.var_javax_microedition_lcdui_Graphics_a.setColor(6178);
        this.var_javax_microedition_lcdui_Graphics_a.drawLine(n2 -= this.bF - 10, n3 += 2, n2 + this.bF - 1, n3);
        this.var_javax_microedition_lcdui_Graphics_a.setColor(3564144);
        this.var_javax_microedition_lcdui_Graphics_a.drawLine(n2, ++n3, n2 + this.bF - 1, n3);
        if (this.var_boolean_arr_h[this.bE]) {
            n2 += 6;
            n3 += 8;
            if (this.var_byte_arr_y[this.bE] < 51) {
                this.int_a(this.gamePngImagesGroups[8][18], (int)this.var_byte_arr_y[this.bE], n2 + 48, n3);
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][8], n2 + 50, n3 + 8, 0);
            }
            n2 = 240 + this.bF >> 1;
            this.d(n2 -= 68, n3, 32, 32);
            if (this.var_byte_arr_z[this.bE] == 0) {
                this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                this.var_javax_microedition_lcdui_Graphics_a.drawString(this.var_java_lang_String_arr_e[this.var_byte_arr_z[this.bE]], n2 + (32 - this.var_int_a >> 1), n3 + (32 - this.var_int_b >> 1), 0);
            } else {
                n = this.var_byte_arr_z[this.bE] - 33;
                if (n > 7) {
                    n = 8;
                }
                image = this.gamePngImagesGroups[6][n];
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n2 + (32 - image.getWidth() >> 1), n3 + (32 - image.getHeight() >> 1), 0);
            }
            this.d(n2 += 34, n3, 32, 32);
            if (this.var_byte_arr_A[this.bE] == 0) {
                this.var_javax_microedition_lcdui_Graphics_a.setColor(-1);
                this.var_javax_microedition_lcdui_Graphics_a.drawString(this.var_java_lang_String_arr_e[this.var_byte_arr_A[this.bE]], n2 + (32 - this.var_int_a >> 1), n3 + (32 - this.var_int_b >> 1), 0);
            } else {
                n = this.var_byte_arr_A[this.bE] - 33;
                if (n > 7) {
                    n = 9;
                }
                image = this.gamePngImagesGroups[6][n];
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n2 + (32 - image.getWidth() >> 1), n3 + (32 - image.getHeight() >> 1), 0);
            }
            n2 = 240 - this.bF + 10 >> 1;
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[8][1], n2, n3 += 20, 0);
            this.int_a(this.gamePngImagesGroups[8][2], this.var_int_arr_D[this.bE], n2 += 60, n3 + 2);
            this.a(this.gamePngImagesGroups[8][7], n2 -= 64, n3 += 16, 0, 2, 10, 10);
            this.d((n2 += 15) - 1, n3, 48, 12);
            this.int_a(this.gamePngImagesGroups[8][2], this.var_int_arr_x[this.bE], n2 + 45, n3 + 2);
            this.a(this.gamePngImagesGroups[8][7], n2 += 47, n3, 10, 0, 10, 13);
            this.var_javax_microedition_lcdui_Graphics_a.setColor(512);
            this.d(n2 += 11, n3, 30, 12);
            this.int_a(this.gamePngImagesGroups[8][2], this.var_int_arr_y[this.bE], n2 + 28, n3 + 2);
            this.a(this.gamePngImagesGroups[8][7], n2 += 32, n3, 20, 2, 10, 10);
            this.var_javax_microedition_lcdui_Graphics_a.setColor(512);
            this.d(n2 += 12, n3, 30, 12);
            this.int_a(this.gamePngImagesGroups[8][2], this.var_int_arr_z[this.bE], n2 + 28, n3 + 2);
            n2 = (240 - this.bF >> 1) + 6;
            this.void_a(0, this.var_int_arr_A[this.bE], n2, n3 += 16);
            this.void_a(1, this.var_int_arr_B[this.bE], n2 += 42, n3);
            this.void_a(2, this.var_int_arr_C[this.bE], n2 += 42, n3);
        }
    }

    private void q(int n) {
        this.p(n);
        Object object = "MOT_L" + n;
        a.void_a((String)object);
        try {
            int n2;
            this.var_javax_microedition_rms_RecordStore_a = RecordStore.openRecordStore((String)object, (boolean)true);
            this.var_java_io_ByteArrayOutputStream_a = new ByteArrayOutputStream();
            this.var_java_io_DataOutputStream_a = new DataOutputStream(this.var_java_io_ByteArrayOutputStream_a);
            this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_A);
            this.var_java_io_DataOutputStream_a.writeByte(this.level);
            this.var_java_io_DataOutputStream_a.writeByte(this.an);
            this.var_java_io_DataOutputStream_a.writeByte(this.ao);
            this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_m);
            this.var_java_io_DataOutputStream_a.writeByte(this.playerWeapon);
            this.var_java_io_DataOutputStream_a.writeByte(this.playerCloth);
            this.var_java_io_DataOutputStream_a.writeShort(this.playerXOffset);
            this.var_java_io_DataOutputStream_a.writeShort(this.playerYOffest);
            this.var_java_io_DataOutputStream_a.writeInt(this.playerHp);
            this.var_java_io_DataOutputStream_a.writeInt(this.playerAttack);
            this.var_java_io_DataOutputStream_a.writeInt(this.playerAmaor);
            this.var_java_io_DataOutputStream_a.writeShort(this.yellowKeyCount);
            this.var_java_io_DataOutputStream_a.writeShort(this.blueKeyCount);
            this.var_java_io_DataOutputStream_a.writeShort(this.redKeyCount);
            this.var_java_io_DataOutputStream_a.writeInt(this.aQ);
            this.var_java_io_DataOutputStream_a.writeShort(this.ar);
            this.var_java_io_DataOutputStream_a.writeShort(this.aL);
            for (n2 = 0; n2 < this.aL; ++n2) {
                this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_arr_o[n2]);
                this.var_java_io_DataOutputStream_a.writeByte(this.var_byte_arr_p[n2]);
            }
            for (n2 = 0; n2 < 128; ++n2) {
                if (n2 < this.bj) {
                    this.var_java_io_DataOutputStream_a.writeBoolean(this.var_boolean_arr_g[n2]);
                    continue;
                }
                this.var_java_io_DataOutputStream_a.writeBoolean(false);
            }
            this.var_java_io_DataOutputStream_a.writeByte(this.bagItemCount);
            for (n2 = 0; n2 < this.bagItemCount; ++n2) {
                this.var_java_io_DataOutputStream_a.writeByte(this.playerBagArray[n2]);
                this.var_java_io_DataOutputStream_a.writeByte(this.itemCurrentUseContArray[n2]);
            }
            for (n2 = 0; n2 < 56; ++n2) {
                if (this.levelSpritesData[n2] != null) {
                    this.var_java_io_DataOutputStream_a.writeShort(this.levelSpritesData[n2].length);
                    this.var_java_io_DataOutputStream_a.write(this.levelSpritesData[n2], 0, this.levelSpritesData[n2].length);
                    continue;
                }
                this.var_java_io_DataOutputStream_a.writeShort(-1);
            }
            this.var_javax_microedition_rms_RecordStore_a.addRecord(this.var_java_io_ByteArrayOutputStream_a.toByteArray(), 0, this.var_java_io_ByteArrayOutputStream_a.size());
            return;
        }
        catch (Exception exception) {
            object = exception;
            exception.printStackTrace();
            return;
        }
        finally {
            this.B();
        }
    }

    private boolean boolean_e(int n) {
        boolean bl = true;
        short s = 0;
        Object object = "MOT_L" + n;
        try {
            this.var_javax_microedition_rms_RecordStore_a = RecordStore.openRecordStore((String)object, (boolean)false);
            this.var_javax_microedition_rms_RecordEnumeration_a = this.var_javax_microedition_rms_RecordStore_a.enumerateRecords(null, null, false);
            int n2 = this.var_javax_microedition_rms_RecordEnumeration_a.nextRecordId();
            this.var_byte_arr_B = this.var_javax_microedition_rms_RecordStore_a.getRecord(n2);
            this.var_java_io_DataInputStream_a = new DataInputStream(new ByteArrayInputStream(this.var_byte_arr_B));
            this.var_byte_A = this.var_java_io_DataInputStream_a.readByte();
            this.level = this.var_java_io_DataInputStream_a.readByte();
            this.an = this.var_java_io_DataInputStream_a.readByte();
            this.ao = this.var_java_io_DataInputStream_a.readByte();
            this.var_byte_m = this.var_java_io_DataInputStream_a.readByte();
            this.playerWeapon = this.var_java_io_DataInputStream_a.readByte();
            this.playerCloth = this.var_java_io_DataInputStream_a.readByte();
            this.playerXOffset = this.var_java_io_DataInputStream_a.readShort();
            this.playerYOffest = this.var_java_io_DataInputStream_a.readShort();
            this.playerPixelX = this.playerXOffset << 5;
            this.playerPixelY = this.playerYOffest << 5;
            this.playerHp = this.var_java_io_DataInputStream_a.readInt();
            this.playerAttack = this.var_java_io_DataInputStream_a.readInt();
            this.playerAmaor = this.var_java_io_DataInputStream_a.readInt();
            this.yellowKeyCount = this.var_java_io_DataInputStream_a.readShort();
            this.blueKeyCount = this.var_java_io_DataInputStream_a.readShort();
            this.redKeyCount = this.var_java_io_DataInputStream_a.readShort();
            this.aQ = this.var_java_io_DataInputStream_a.readInt();
            this.ar = this.var_java_io_DataInputStream_a.readShort();
            this.var_int_R = 0;
            this.aL = this.var_java_io_DataInputStream_a.readShort();
            for (n2 = 0; n2 < this.aL; ++n2) {
                this.var_byte_arr_o[n2] = this.var_java_io_DataInputStream_a.readByte();
                this.var_byte_arr_p[n2] = this.var_java_io_DataInputStream_a.readByte();
            }
            for (n2 = 0; n2 < this.bj; ++n2) {
                this.var_boolean_arr_g[n2] = this.var_java_io_DataInputStream_a.readBoolean();
            }
            if (this.bj < 128) {
                this.var_java_io_DataInputStream_a.skip(128 - this.bj);
            }
            this.isJDYEnabled = false;
            this.bagItemCount = this.var_java_io_DataInputStream_a.readByte();
            for (n2 = 0; n2 < this.bagItemCount; ++n2) {
                this.playerBagArray[n2] = this.var_java_io_DataInputStream_a.readByte();
                this.itemCurrentUseContArray[n2] = this.var_java_io_DataInputStream_a.readByte();
                if (this.playerBagArray[n2] != 15) continue;
                this.isJDYEnabled = true;
            }
            for (n2 = 0; n2 < 56; ++n2) {
                s = this.var_java_io_DataInputStream_a.readShort();
                if (s > 0) {
                    this.levelSpritesData[n2] = new byte[s];
                    this.var_java_io_DataInputStream_a.read(this.levelSpritesData[n2], 0, s);
                    continue;
                }
                this.levelSpritesData[n2] = null;
            }
            this.void_g(this.var_int_arr_H[this.var_byte_A]);
        }
        catch (Exception exception) {
            object = exception;
            exception.printStackTrace();
            bl = false;
        }
        finally {
            this.B();
        }
        return bl;
    }

    private static void void_a(String string) {
        try {
            RecordStore.deleteRecordStore((String)string);
            return;
        }
        catch (Exception exception) {
            return;
        }
    }

    private void B() {
        if (this.var_javax_microedition_rms_RecordStore_a != null) {
            try {
                this.var_javax_microedition_rms_RecordStore_a.closeRecordStore();
            }
            catch (Exception exception) {}
        }
        if (this.var_java_io_ByteArrayOutputStream_a != null) {
            try {
                this.var_java_io_ByteArrayOutputStream_a.close();
            }
            catch (Exception exception) {}
        }
        if (this.var_java_io_DataOutputStream_a != null) {
            try {
                this.var_java_io_DataOutputStream_a.close();
            }
            catch (Exception exception) {}
        }
        if (this.var_javax_microedition_rms_RecordEnumeration_a != null) {
            this.var_javax_microedition_rms_RecordEnumeration_a.destroy();
        }
        this.var_javax_microedition_rms_RecordStore_a = null;
        this.var_java_io_ByteArrayOutputStream_a = null;
        this.var_java_io_DataOutputStream_a = null;
        this.var_javax_microedition_rms_RecordEnumeration_a = null;
        this.var_byte_arr_B = null;
        System.gc();
    }

    private void C() {
        int n = 56;
        while (--n >= 0) {
            this.levelSpritesData[n] = null;
        }
    }

    private void r(int n) {
        int n2 = this.levelActorCount;
        int n3 = this.levelActorCount;
        while (--n3 >= 0) {
            if (!this.var_boolean_arr_b[n3] && this.var_byte_arr_e[n3] != 1) continue;
            --n2;
        }
        this.levelSpritesData[n] = null;
        if (this.levelActorCount > 0) {
            this.levelSpritesData[n] = new byte[(n2 << 3) + 2];
            this.var_byte_arr_C = this.levelSpritesData[n];
            this.bH = 0;
            this.a((short)n2);
            for (n3 = 0; n3 < this.levelActorCount; ++n3) {
                if (this.var_boolean_arr_b[n3] || this.var_byte_arr_e[n3] == 1) continue;
                this.var_byte_arr_C[this.bH++] = this.objectIdLookupTable[n3];
                this.a((short)this.mapObjectPixelX[n3]);
                this.a((short)this.mapObjectPixelY[n3]);
                this.var_byte_arr_C[this.bH++] = this.spritePassable[n3] ? (byte)1 : 0;
                this.a(this.npcTalkIndexLookupTable[n3]);
            }
        }
    }

    private void a(short s) {
        this.var_byte_arr_C[this.bH++] = (byte)(s >> 8);
        this.var_byte_arr_C[this.bH++] = (byte)s;
    }

    /*
     * Loose catch block
     */
    private void loadLevel(int n) {
        block11: {
            int n2 = n;
            InputStream inputStream = this.getClass().getResourceAsStream("maplv" + n2);
            this.m_mapWidth = a.readBinaryShort(inputStream) >> 1;
            this.m_mapHeight = a.readBinaryShort(inputStream) >> 1;
            System.out.println("Width:" + this.m_mapWidth + ",Height:" + this.m_mapHeight);
            int n3 = this.m_mapWidth * this.m_mapHeight << 2;
            this.pixelWidth = this.m_mapWidth << 5;
            this.pixelHeight = this.m_mapHeight << 5;
            this.passableArray = new byte[n3];
            this.tileOperateModeArray = new byte[n3];
            inputStream.read(this.passableArray, 0, n3);
            inputStream.read(this.tileOperateModeArray, 0, n3);
            a.javax_microedition_lcdui_Image_a(32, 32, 0x55FF00FF);
            a.javax_microedition_lcdui_Image_a(32, 32, 0x5500FF00);
            try {
                inputStream.close();
            }
            catch (Exception exception) {}
            break block11;
            catch (Exception exception) {
                try {
                    Exception exception2 = exception;
                    exception.printStackTrace();
                }
                catch (Throwable throwable) {
                    try {
                        inputStream.close();
                    }
                    catch (Exception exception3) {}
                    throw throwable;
                }
                try {
                    inputStream.close();
                }
                catch (Exception exception4) {}
            }
        }
        this.preferWidth = 240;
        this.perferHeight = 252;
        this.var_boolean_k = this.preferWidth >= this.pixelWidth;
        this.var_boolean_l = this.perferHeight >= this.pixelHeight;
        this.s();   //初始化数据
        this.mapPassBitmap = new boolean[this.m_mapHeight][this.m_mapWidth];
        this.i(0, 0);
        this.initPassthrough();
        this.levelActorCount = 0;
        this.downY = -1;
        this.downX = -1;
        this.upperY = -1;
        this.upperX = -1;
        this.loadLevelSprites(n);
        this.p();
    }

    private void loadLevelSprites(int n) {
        int n2;
        boolean bl = false;
        boolean bl2 = false;
        int n3 = 0;
        this.levelActorCount = 0;
        for (n2 = 1; n2 <= 12; ++n2) {
            this.actorSpriteImages[n2] = this.gamePngImagesGroups[4][n2 - 1];
        }
        for (n2 = 13; n2 <= 32; ++n2) {
            this.actorSpriteImages[n2] = this.gamePngImagesGroups[5][n2 - 13 + 1];
        }
        for (n2 = 33; n2 <= 40; ++n2) {
            this.actorSpriteImages[n2] = this.gamePngImagesGroups[6][n2 - 33];
        }
        for (n2 = 41; n2 < 61; ++n2) {
            this.actorSpriteImages[n2] = this.gamePngImagesGroups[7][n2 - 41];
        }
        for (n2 = 61; n2 < 79; ++n2) {
            this.actorSpriteImages[n2] = this.gamePngImagesGroups[13][n2 - 41 - 20];
        }
        this.actorSpriteImages[84] = this.gamePngImagesGroups[13][18];  //嫦娥 = sptenemy2_18.png
        this.actorSpriteImages[87] = this.gamePngImagesGroups[13][19];  //菩提老祖
        this.actorSpriteImages[85] = this.gamePngImagesGroups[5][21];   //黄金钥匙
        this.actorSpriteImages[86] = this.gamePngImagesGroups[5][22];   //日月无极拨
        this.actorSpriteImages[79] = this.gamePngImagesGroups[6][8];    //乌金棍
        this.actorSpriteImages[80] = this.gamePngImagesGroups[6][9];    //银缕锁甲
        this.actorSpriteImages[12] = this.actorSpriteImages[11];
        this.actorSpriteImages[81] = this.gamePngImagesGroups[4][3];    //封印门
        this.actorSpriteImages[71] = this.actorSpriteImages[70];
        this.levelActorCount = 0;
        if (this.levelSpritesData[n] == null) {
            try {
                int n4 = n;
                InputStream inputStream = this.getClass().getResourceAsStream("sprite" + n4);
                boolean bl3 = false;
                int n5 = 0;
                try {
                    int nCount = a.readBinaryShort(inputStream) & 0xFFFF | a.readBinaryShort(inputStream) << 16;
                    block27: for (int i = 0; i < nCount; ++i) {
                        int objectId = inputStream.read();
                        n3 = a.readBinaryShort(inputStream);
                        short s = a.readBinaryShort(inputStream);
                        switch (objectId) {
                            case 6:     //隐形路径
                            case 12: {  //隐形墙
                                objectId = this.loadSpritePropertyInternal(objectId, n3, (int)s, 0);
                                this.spritePassable[objectId] = false;
                                continue block27;
                            }
                            case 9: {   //炼丹炉
                                n5 = inputStream.read();
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                continue block27;
                            }
                            case 4: {   //封印门
                                n5 = inputStream.read() + 1;
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                continue block27;
                            }
                            case 5:     //门卫
                            case 81: {  //封印门
                                n5 = inputStream.read() + 1;
                                objectId = this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                this.spritePassable[objectId] = false;
                                continue block27;
                            }
                            case 83: {  //剧情点
                                n5 = inputStream.read();
                                objectId = this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                this.spritePassable[objectId] = false;
                                continue block27;
                            }
                            case 7:     //上楼梯
                            case 8: {   //下楼梯
                                n5 = inputStream.read() | inputStream.read() << 8;
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                continue block27;
                            }
                            case 57:    //赤力韦驮
                            case 59:    //伏魔韦驮
                            case 70:    //玉皇大帝
                            case 71:    //玉皇大帝
                            case 72:    //牛魔王
                            case 73: {  //封印门
                                n5 = inputStream.read() + 1;
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                continue block27;
                            }
                            case 77: {
                                n5 = inputStream.read();
                                n5 = n5 & 0xFF | this.var_byte_arr_m[n5 - 1] << 8;
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                continue block27;
                            }
                            case 78: {
                                n5 = inputStream.read();
                                n5 = n5 & 0xFF | this.var_byte_arr_n[n5 - 1] << 8;
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                continue block27;
                            }
                            case 76:
                            case 82: {
                                n5 = inputStream.read() | inputStream.read() + 1 << 8;
                                objectId = this.loadSpritePropertyInternal(objectId, n3, (int)s, n5);
                                this.spritePassable[objectId] = false;
                                continue block27;
                            }
                            default: {
                                this.loadSpritePropertyInternal(objectId, n3, (int)s, 0);
                            }
                        }
                    }
                }
                catch (Exception exception) {
                    Exception exception2 = exception;
                    exception.printStackTrace();
                }
            }
            catch (Exception exception) {}
        } else {
            this.var_byte_arr_D = this.levelSpritesData[n];
            this.bI = 0;
            int n8 = this.int_b();
            for (int i = 0; i < n8; ++i) {
                byte by = this.var_byte_arr_D[this.bI++];
                n2 = this.int_b();
                int n9 = this.int_b();
                boolean bl4 = this.var_byte_arr_D[this.bI++] != 0;
                n3 = this.int_b();
                this.loadSpritePropertyInternal((int)by, n2, n9, n3);
                this.spritePassable[i] = bl4;
                this.var_boolean_arr_b[i] = false;
            }
            switch (this.level) {
                case 31: {
                    break;
                }
                case 12: {
                    n8 = this.int_b(1, 1, 78);  //天宫商人
                    if (n8 >= 0) {
                        this.npcTalkIndexLookupTable[n8] = 6 | this.var_byte_arr_n[5] << 8;
                    }
                    if ((n8 = this.int_b(11, 1, 78)) < 0) break;
                    this.npcTalkIndexLookupTable[n8] = 5 | this.var_byte_arr_n[4] << 8;
                    break;
                }
                case 2: {
                    if (this.var_boolean_arr_g[26] || this.int_b(11, 4, 84) >= 0) break;
                    this.loadSpritePropertyInternal(84, 352, 128, 0);
                    break;
                }
                case 39: {
                    n8 = this.int_b(11, 1, 7);
                    if (n8 >= 0) {
                        this.void_a(11, 1, 7);
                        this.loadSpritePropertyInternal(8, 11, 1, 38);
                    }
                    if ((n8 = this.int_b(11, 11, 8)) < 0) break;
                    this.void_a(11, 11, 8);
                    this.loadSpritePropertyInternal(7, 11, 11, 40);
                }
            }
        }
        if (n != 50) {
            this.objectTypeLookupTable[72] = 32;
            return;
        }
        this.objectTypeLookupTable[72] = 8;
    }

    private int int_b() {
        return (this.var_byte_arr_D[this.bI++] & 0xFF) << 8 | this.var_byte_arr_D[this.bI++] & 0xFF;
    }

    private void m(int n, int n2) {
        if (this.var_byte_v < 64) {
            this.var_short_arr_h[this.var_byte_v] = n;
            this.var_short_arr_i[this.var_byte_v] = n2;
            this.var_byte_v = (byte)(this.var_byte_v + 1);
        }
    }

    private void a(byte by, int n, int n2, int n3) {
        n2 += this.ae;
        this.var_byte_arr_E[this.bK] = by;
        this.var_int_arr_E[this.bK] = n;
        this.var_boolean_arr_i[this.bK] = false;
        this.var_byte_arr_F[this.bK] = 0;
        this.var_short_arr_k[this.bK] = n3 += this.af;
        if (by == 4) {
            this.var_short_arr_j[this.bK] = 240;
            this.var_short_arr_k[this.bK] = 30;
        } else if (by >= 5 && by <= 7) {
            this.var_short_arr_j[this.bK] = n2 + 16;
        } else if (by == 1) {
            this.var_short_arr_j[this.bK] = n2 - 2;
        } else {
            int n4;
            int n5 = n2;
            Image image = this.gamePngImagesGroups[2][3];
            n2 = n4 = image.getWidth() / 11;
            if (n < 0) {
                n = -n;
            }
            do {
                n2 += n4;
            } while ((n /= 10) > 0);
            this.var_short_arr_j[this.bK] = n5 + (32 + n2 >> 1);
        }
        if (++this.bK >= 30) {
            this.bK = 0;
        }
    }

    private void D() {
        byte by = 0;
        int n = this.bJ;
        while (true) {
            if (n >= 30) {
                n = 0;
            }
            if (n == this.bK) break;
            if (!this.var_boolean_arr_i[n]) {
                byte by2 = this.var_byte_arr_E[n];
                int n2 = this.var_int_arr_E[n];
                int n3 = 0 + this.var_short_arr_j[n];
                by = this.var_byte_arr_F[n];
                int n4 = 16 + this.var_short_arr_k[n];
                switch (by2) {
                    case 1: {
                        this.a(this.gamePngImagesGroups[2][6], n3, n4 -= this.var_byte_arr_F[n] << 2, 0, 19 * n2, 37, 19);
                        break;
                    }
                    case 2: {
                        this.b(this.gamePngImagesGroups[2][3], n2, n3, n4 -= this.var_byte_arr_F[n] << 2);
                        break;
                    }
                    case 3: {
                        this.b(this.gamePngImagesGroups[2][4], n2, n3, n4 -= this.var_byte_arr_F[n] << 2);
                        break;
                    }
                    case 4: {
                        this.b(this.gamePngImagesGroups[2][5], n2, n3, n4 -= this.var_byte_arr_F[n] << 2);
                        break;
                    }
                    case 5: {
                        this.int_a(this.gamePngImagesGroups[8][9], n2, n3 + this.var_byte_arr_G[by], 16 + this.var_short_arr_k[n] + this.var_byte_arr_H[by]);
                        break;
                    }
                    case 6: {
                        this.int_a(this.gamePngImagesGroups[8][9], n2, n3 + this.var_byte_arr_I[by], 16 + this.var_short_arr_k[n] + this.var_byte_arr_J[by]);
                        break;
                    }
                    case 7: {
                        this.int_a(this.gamePngImagesGroups[8][9], n2, n3 + this.var_byte_arr_K[by], 16 + this.var_short_arr_k[n] + this.var_byte_arr_L[by]);
                    }
                }
                if (by > 7) {
                    this.var_boolean_arr_i[n] = true;
                } else {
                    int n5 = n;
                    this.var_byte_arr_F[n5] = this.var_byte_arr_F[n5] + 1;
                }
            }
            ++n;
        }
        if (this.bJ != this.bK && this.var_boolean_arr_i[this.bJ] && ++this.bJ >= 30) {
            this.bJ = 0;
        }
    }

    private int b(Image image, int n, int n2, int n3) {
        int n4 = n < 0 ? 1 : 0;
        if (n4 != 0) {
            n = -n;
        }
        n4 = image.getWidth() / 11;
        int n5 = image.getHeight();
        int n6 = 0;
        int n7 = 0;
        do {
            n6 = n % 10;
            this.var_javax_microedition_lcdui_Graphics_a.setClip(n2 -= n4 + 1, n3, n4, n5);
            this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n2 - n6 * n4, n3, 0);
            ++n7;
        } while ((n /= 10) > 0);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(n2 -= n4 + 1, n3, n4, n5);
        this.var_javax_microedition_lcdui_Graphics_a.drawImage(image, n2 - (image.getWidth() - n4), n3, 0);
        this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        return n7 + 1;
    }

    private void E() {
        this.var_short_arr_l = new short[32];
        this.var_short_arr_m = new short[32];
        this.var_byte_arr_M = new byte[32];
        this.var_byte_arr_N = new byte[32];
        this.var_byte_arr_O = new byte[32];
        this.var_byte_w = 0;
        this.var_int_arr_F = new int[32];
        this.var_boolean_arr_j = new boolean[32];
        this.var_boolean_arr_k = new boolean[32];
    }

    private void e(int n, int n2, int n3, int n4) {
        this.var_short_arr_l[this.var_byte_w] = n;
        this.var_short_arr_m[this.var_byte_w] = n2;
        this.var_byte_arr_M[this.var_byte_w] = -3;
        this.var_byte_arr_N[this.var_byte_w] = -4;
        this.var_byte_arr_O[this.var_byte_w] = 2;
        this.var_boolean_arr_j[this.var_byte_w] = true;
        this.var_int_arr_F[this.var_byte_w] = -1;
        this.var_boolean_arr_k[this.var_byte_w] = false;
        this.var_byte_w = (byte)(this.var_byte_w + 1);
        if (this.var_byte_w > 31) {
            this.var_byte_w = 0;
        }
    }

    private void F() {
        byte by = 0;
        int n = 0;
        this.var_javax_microedition_lcdui_Graphics_a.setColor(this.bL);
        int n2 = 32;
        while (--n2 >= 0) {
            if (!this.var_boolean_arr_j[n2]) continue;
            n = this.var_byte_arr_O[n2];
            this.var_javax_microedition_lcdui_Graphics_a.fillRect((int)this.var_short_arr_l[n2], (int)this.var_short_arr_m[n2], n, n);
            by = this.var_byte_arr_M[n2];
            int n3 = n2;
            this.var_short_arr_l[n3] = this.var_short_arr_l[n3] + by;
            n <<= 1;
            if (!this.var_boolean_arr_k[n2]) {
                int n4 = n2;
                this.var_byte_arr_M[n4] = (byte)(this.var_byte_arr_M[n4] + 1);
                if (this.var_byte_arr_M[n4] == n) {
                    this.var_boolean_arr_k[n2] = true;
                }
            } else {
                int n5 = n2;
                this.var_byte_arr_M[n5] = (byte)(this.var_byte_arr_M[n5] - 1);
                if (this.var_byte_arr_M[n5] == -n) {
                    this.var_boolean_arr_k[n2] = false;
                    int n6 = n2;
                    this.var_byte_arr_O[n6] = (byte)(this.var_byte_arr_O[n6] + 1);
                    if (this.var_byte_arr_O[n6] > 5) {
                        this.var_boolean_arr_j[n2] = false;
                    }
                }
            }
            int n7 = n2;
            this.var_short_arr_m[n7] = this.var_short_arr_m[n7] + this.var_byte_arr_N[n2];
        }
    }

    private void a(byte by, boolean bl) {
        this.var_byte_y = (byte)3;
        this.var_boolean_t = true;
        if (this.var_byte_arr_P == null) {
            this.var_byte_arr_P = new byte[16];
        }
        this.bP = 0;
        this.bO = 0;
        this.gameStateFlag = (byte)2;
        this.void_a(15);
    }

    private void u(int n) {
        this.var_byte_arr_P[this.bO++] = n;
    }

    private boolean boolean_a(int n, int n2, int n3, int n4) {
        a a2 = this;
        this.var_byte_arr_Q = new byte[100];
        a2.bS = 0;
        a2.var_byte_arr_arr_g = new byte[a2.Z][a2.Y];
        a2.var_short_arr_arr_a = new short[a2.Z][a2.Y];
        a2.var_short_arr_n = new short[100];
        a2.var_short_arr_o = new short[100];
        a2.bT = 0;
        boolean bl = false;
        int n5 = n;
        int n6 = n2;
        int n7 = this.m_mapWidth;
        int n8 = n5 + n6 * n7;
        this.var_short_a = (short)n;
        this.var_short_b = (short)n2;
        this.var_short_c = (short)n3;
        this.var_short_d = (short)n4;
        this.bT = 1;
        n3 = 0;
        do {
            this.g(n5 - 1, n6, n8);
            this.g(n5 + 1, n6, n8);
            this.g(n5, n6 - 1, n8);
            this.g(n5, n6 + 1, n8);
            if (this.bT <= 0) break;
            n8 = this.var_short_arr_o[this.bT - 1];
            n5 = n8 % n7;
            n6 = n8 / n7;
            --this.bT;
            this.var_byte_arr_arr_g[n6][n5] = 2;
            if (n5 != this.var_short_c || n6 != this.var_short_d) continue;
            bl = true;
        } while (++n3 < 100 && !bl);
        n3 = 0;
        n += n2 * n7;
        n2 = 0;
        if (bl) {
            do {
                if ((n2 = (n3 = this.var_short_arr_arr_a[n6][n5]) - n8) == -1) {
                    this.var_byte_arr_Q[this.bS++] = 2;
                } else if (n2 == 1) {
                    this.var_byte_arr_Q[this.bS++] = 3;
                } else if (n2 == -n7) {
                    this.var_byte_arr_Q[this.bS++] = 0;
                } else if (n2 == n7) {
                    this.var_byte_arr_Q[this.bS++] = 1;
                } else {
                    return false;
                }
                n8 = n3;
                n5 = n3 % n7;
                n6 = n3 / n7;
            } while (n3 != n);
        }
        return bl;
    }

    private void g(int n, int n2, int n3) {
        short s = 0;
        if (this.var_byte_arr_arr_g[n2][n] == 0 && (this.boolean_b(n, n2) || this.boolean_c(n, n2))) {
            this.var_byte_arr_arr_g[n2][n] = 1;
            this.var_short_arr_arr_a[n2][n] = n3;
            s = (short)(Math.abs(n - this.var_short_c) + Math.abs(n2 - this.var_short_d) + Math.abs(n - this.var_short_a) + Math.abs(n2 - this.var_short_b));
            n3 = this.bT;
            while (--n3 >= 0) {
                if (s >= this.var_short_arr_n[n3] && n3 != 0) continue;
                for (int i = this.bT; i > n3 + 1; --i) {
                    this.var_short_arr_n[i] = this.var_short_arr_n[i - 1];
                    this.var_short_arr_o[i] = this.var_short_arr_o[i - 1];
                }
                this.var_short_arr_n[++n3] = s;
                this.var_short_arr_o[n3] = n + n2 * this.m_mapWidth;
                break;
            }
            ++this.bT;
        }
    }

    private int caculateHpReduce(int n, boolean bl) {
        int attack = this.getRealAttack(n);
        return a.battle(attack, this.playerAmaor, this.monsterHpArray[n -= 41], this.monsterAttackArray[n], this.monsterDefArray[n], bl);
    }

    private int getRealAttack(int n) {
        n = this.monsterSpecialEffectArray[n];     ////74 巨灵神 53 金刚力士 49 巨力士 69 杨戬
        int damageRate = 1;
        if ((n & 1) != 0 && this.getBagItemIndex(23) >= 0) {    //23 太公杖 对 巨灵神 金刚力士 巨力士 双倍伤害
            damageRate = 2;
        } else if ((n & 2) != 0 && this.getBagItemIndex(24) >= 0) { //24 捆仙绳对 杨戬 双倍伤害
            damageRate = 2;
        }
        return this.playerAttack * damageRate;
    }

    private static int battle(int playerAttack, int playerDef, int monsterHp, int monsterAttack, int monsterDef, boolean bl) {
        int hpReduce = -1;
        int battleRound = 0;
        if (playerAttack > monsterDef) {
            battleRound = monsterHp / (playerAttack - monsterDef);
            if (battleRound * (playerAttack - monsterDef) < monsterHp) {
                ++battleRound;
            }
            hpReduce = battleRound > 1 && monsterAttack > playerDef ? (monsterAttack - playerDef) * (battleRound - 1) : 0;
            if (!bl && monsterAttack > playerDef) {
                hpReduce += monsterAttack - playerDef;
            }
        }
        return hpReduce;
    }

    private void c(boolean bl) {
        if (!this.var_boolean_x) {
            if (this.var_int_S < 0) {
                this.var_byte_l = 0;
                return;
            }
            int a2 = this.objectIdLookupTable[this.var_int_S];
            int n = this.getRealAttack(a2) - this.monsterDefArray[a2 - 41];
            if (n > 0) {
                if ((this.bV & 3) == 0) {
                    this.bU -= n;
                    this.a((byte)(5 + this.bV % 3), n, this.mapObjectPixelX[this.var_int_S], this.mapObjectPixelY[this.var_int_S]);
                    if (this.bU > 0) {
                        n = this.monsterAttackArray[a2 - 41] - this.playerAmaor;
                        if (n > 0) {
                            this.playerHp -= n;
                        }
                    } else {
                        boolean bl2;
                        n = this.caculateHpReduce(a2, this.var_boolean_z);
                        if (n > 0) {
                            this.a((byte)2, n, this.playerPixelX, this.playerPixelY);
                        }
                        if (this.getBagItemIndex(25) >= 0) {
                            this.addMoney(this.monsterMoneyLookupTable[a2 - 41] << 1, this.mapObjectPixelX[this.var_int_S], this.mapObjectPixelY[this.var_int_S]);
                        } else {
                            this.addMoney(this.monsterMoneyLookupTable[a2 - 41], this.mapObjectPixelX[this.var_int_S], this.mapObjectPixelY[this.var_int_S]);
                        }
                        n = this.objectIdLookupTable[this.var_int_S];
                        boolean bl3 = false;
                        if (this.level > 50) {
                            bl2 = false;
                        } else {
                            int n2 = this.var_byte_arr_x.length;
                            while (--n2 >= 0) {
                                if (n != this.var_byte_arr_x[n2]) continue;
                                this.o(n2);
                                break;
                            }
                            switch (n) {
                                case 73: {
                                    this.var_boolean_arr_g[this.bh] = true;
                                    this.boolean_d(22);
                                    if (this.level != 40) break;
                                    this.o(6);
                                    break;
                                }
                                case 74: {
                                    this.boolean_d(21);
                                    break;
                                }
                                case 75: {
                                    if (!this.b(20, true)) break;
                                    this.boolean_d(20);
                                    bl3 = true;
                                }
                            }
                            bl2 = bl3;
                        }
                        this.var_boolean_y = bl2;
                        this.var_boolean_x = true;
                    }
                }
            } else {
                this.var_byte_l = 0;
            }
            ++this.bV;
            return;
        }
        if (this.var_byte_B == 0) {
            this.void_e(this.var_int_S);
        }
        if ((this.var_byte_B = (byte)(this.var_byte_B + 1)) > 5) {
            this.var_byte_B = 0;
            if (!this.var_boolean_y && bl) {
                this.a(this.var_byte_m);
            }
            this.var_boolean_x = false;
            int n = this.objectIdLookupTable[this.var_int_S];
            a a2 = this;
            switch (n) {
                case 70:
                case 71: {
                    if (a2.level != 49) break;
                    a2.boolean_d(35);
                    break;
                }
                case 61: {
                    if (a2.level != 49 || a2.int_b(6, 2, 61) >= 0 || a2.int_b(5, 3, 61) >= 0 || a2.int_b(7, 3, 61) >= 0 || a2.int_b(6, 4, 61) >= 0 || a2.int_b(5, 2, 61) < 0 || a2.int_b(7, 2, 61) < 0 || a2.int_b(5, 4, 61) < 0 || a2.int_b(7, 4, 61) < 0) break;
                    a2.void_a(6, 3, 70);
                    a2.int_a(71, 192, 96, 0);
                    break;
                }
                case 72: {
                    if (a2.level != 50) break;
                    a2.boolean_d(65);
                    break;
                }
                case 69: {
                    if (a2.level != 35) break;
                    a2.o(7);
                    a2.boolean_d(36);
                }
            }
            this.var_int_S = -1;
        }
    }

    private void a(byte by, int n) {
        if (!this.var_boolean_D) {
            return;
        }
        this.var_java_io_InputStream_a = null;
        try {
            block19: {
                if (this.var_byte_C != by || var_javax_microedition_media_Player_a == null) break block19;
                switch (var_javax_microedition_media_Player_a.getState()) {
                    case 400: {
                        var_javax_microedition_media_Player_a.stop();
                    }
                    case 300: {
                        try {
                            var_javax_microedition_media_Player_a.setLoopCount(-1);
                        }
                        catch (Exception exception) {}
                        var_javax_microedition_media_Player_a.start();
                        return;
                    }
                }
            }
            this.G();
            this.var_java_io_InputStream_a = this.getClass().getResourceAsStream(this.var_java_lang_String_arr_p[by]);
            var_javax_microedition_media_Player_a = Manager.createPlayer((InputStream)this.var_java_io_InputStream_a, (String)(this.var_java_lang_String_arr_p[by].endsWith("wav") ? "audio/x-wav" : "audio/midi"));
            var_javax_microedition_media_Player_a.realize();
            var_javax_microedition_media_Player_a.prefetch();
            try {
                var_javax_microedition_media_Player_a.setLoopCount(-1);
            }
            catch (Exception exception) {
                Exception exception2 = exception;
                exception.printStackTrace();
            }
            int n2 = this.bZ;
            a a2 = this;
            a2 = var_javax_microedition_media_Player_a;
            if (a2 != null && ((a2.getState() & 0x12C) == 300 || (a2.getState() & 0x190) == 400)) {
                try {
                    ((VolumeControl)var_javax_microedition_media_Player_a.getControl("VolumeControl")).setLevel(n2);
                }
                catch (Exception exception) {}
            }
            var_javax_microedition_media_Player_a.start();
            this.var_byte_C = by;
            return;
        }
        catch (Exception exception) {
            Exception exception3 = exception;
            exception.printStackTrace();
            return;
        }
        finally {
            this.void_b();
        }
    }

    private void G() {
        if (var_javax_microedition_media_Player_a != null) {
            var_javax_microedition_media_Player_a.close();
        }
        var_javax_microedition_media_Player_a = null;
        this.var_byte_C = (byte)-1;
    }

    private int int_g(int n) {
        return (this.var_java_util_Random_a.nextInt() >>> 1) % n;
    }

    private void a(String string, int n, int n2, int n3, int[] nArray) {
        this.var_javax_microedition_lcdui_Graphics_a.setColor(nArray[0]);
        int n4 = --n;
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n4, --n2, 17);
        int n5 = ++n;
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n5, n2, 17);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, ++n, n2++, 17);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n, n2++, 17);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n--, n2, 17);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n--, n2, 17);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n, n2--, 17);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n++, n2, 17);
        this.var_javax_microedition_lcdui_Graphics_a.setColor(nArray[1]);
        this.var_javax_microedition_lcdui_Graphics_a.drawString(string, n, n2, 17);
    }

    private void n(int n, int n2) {
        int n3;
        a a2;
        if (!this.var_boolean_E) {
            a2 = this;
            a2.void_a(0);
            n3 = a2.var_byte_arr_T[0] + a2.var_byte_arr_T[1] + a2.var_byte_arr_T[2];
            a2.cb = Math.min(15, Math.abs(320 - n3 >> 2));
            n3 = 320 - n3 - (a2.cb << 1) >> 1;
            a2.objectIdLookupTable[0] = n3 + (a2.var_byte_arr_T[0] >> 1);
            a2.objectIdLookupTable[1] = n3 + a2.var_byte_arr_T[0] + a2.cb;
            a2.objectIdLookupTable[2] = a2.objectIdLookupTable[1] + a2.var_byte_arr_T[1] + a2.cb;
            a2.cc = 240 - a2.var_javax_microedition_lcdui_Image_arr_arr_a[0][7].getWidth() >> 1;
            this.var_boolean_E = true;
        }
        a2 = this;
        block33: for (n3 = a2.var_byte_D - 1; n3 >= 0; --n3) {
            int[] nArray = a2.var_int_arr_arr_d[n3];
            switch (nArray[2]) {
                case 1: {
                    if (nArray[3] <= 0) continue block33;
                    nArray[0] = nArray[0] + (nArray[4] - nArray[0]) / nArray[3];
                    nArray[1] = nArray[1] + (nArray[5] - nArray[1]) / nArray[3];
                    nArray[3] = nArray[3] - 1;
                    continue block33;
                }
                case 3: {
                    if (nArray[3] > 0) {
                        int n4 = (nArray[4] - nArray[0]) / nArray[3];
                        int n5 = (nArray[5] - nArray[1]) / nArray[3];
                        nArray[0] = nArray[0] + n4;
                        nArray[1] = nArray[1] + n5;
                        nArray[3] = nArray[3] - 1;
                        if (nArray[3] != 0) continue block33;
                        int n6 = n4 > 0 ? 8 : (nArray[4] = n4 < 0 ? -8 : 0);
                        nArray[5] = n5 > 0 ? 8 : (n5 < 0 ? -8 : 0);
                        continue block33;
                    }
                    if (nArray[4] != 0) continue block33;
                    switch (nArray[3]) {
                        case -3:
                        case 0: {
                            nArray[0] = nArray[0] + nArray[4];
                            nArray[1] = nArray[1] + nArray[5];
                            break;
                        }
                        case -2: {
                            nArray[4] = nArray[4] >> 1;
                            nArray[5] = nArray[5] >> 1;
                        }
                        case -1: {
                            nArray[0] = nArray[0] - nArray[4];
                            nArray[1] = nArray[1] - nArray[5];
                        }
                    }
                    nArray[3] = nArray[3] - 1;
                    continue block33;
                }
                case 2: {
                    if (nArray[4] <= 1) continue block33;
                    nArray[4] = nArray[4] - 1;
                    continue block33;
                }
                case 4: {
                    if (nArray[3] <= 0) continue block33;
                    switch (nArray[5]) {
                        case 0: {
                            nArray[0] = nArray[0] - nArray[4];
                            nArray[1] = nArray[1] + nArray[4];
                            break;
                        }
                        case 1: {
                            nArray[0] = nArray[0] - nArray[4];
                            nArray[1] = nArray[1] - nArray[4];
                            break;
                        }
                        case 2: {
                            nArray[0] = nArray[0] + nArray[4];
                            nArray[1] = nArray[1] - nArray[4];
                            break;
                        }
                        case 3: {
                            nArray[0] = nArray[0] + nArray[4];
                            nArray[1] = nArray[1] + nArray[4];
                        }
                    }
                    nArray[5] = nArray[5] + 1;
                    if (nArray[5] < 4) continue block33;
                    nArray[5] = 0;
                    nArray[3] = nArray[3] - 1;
                }
            }
        }
        if (n == 0 || n2 < 18) {
            switch (n2) {
                case 1: {
                    this.a(this.gamePngImagesGroups[0][1], 120, 0, 1, 12, 4, 120, this.objectIdLookupTable[0], 0, -1);
                    break;
                }
                case 5: {
                    this.v(0);
                    this.a(this.gamePngImagesGroups[0][0], 120, this.objectIdLookupTable[0], 2, 12, 4, 4, 0, 0, -1);
                    break;
                }
                case 8: {
                    this.a(this.gamePngImagesGroups[0][5], 120, this.objectIdLookupTable[0] + 2, 0, 12, 0, 0, 0, 0, 0);
                    this.a(this.gamePngImagesGroups[0][2], 90, this.objectIdLookupTable[1], 2, 4, 4, 4, 0, 0, -1);
                    this.a(this.gamePngImagesGroups[0][3], 120, this.objectIdLookupTable[1], 2, 4, 4, 4, 0, 0, -1);
                    this.a(this.gamePngImagesGroups[0][4], 150, this.objectIdLookupTable[1], 2, 4, 4, 4, 0, 0, -1);
                    this.a(this.gamePngImagesGroups[0][6], 15, this.objectIdLookupTable[1], 1, 12, 3, this.cc, this.objectIdLookupTable[2], 0, -1);
                    break;
                }
                case 10: {
                    this.v(5);
                    this.a(null, this.cc, this.objectIdLookupTable[2], 3, 0, 0, 0, 0, 0, -1);
                    this.a(5, 4, 0, 1, 2, 0);
                    break;
                }
                case 14: {
                    this.a(5, 3, 0, 3, this.cc - 8, this.objectIdLookupTable[2]);
                    this.a(6, 3, 0, 3, this.cc + this.var_byte_arr_U[2] - 4, this.objectIdLookupTable[2]);
                    break;
                }
                case 15: {
                    this.a(7, 3, 0, 2, this.cc + this.var_byte_arr_U[4] - 2, this.objectIdLookupTable[2]);
                    break;
                }
                case 17: {
                    this.a(5, 3, 0, 3, this.cc, this.objectIdLookupTable[2]);
                    this.a(6, 3, 0, 3, this.cc + this.var_byte_arr_U[2], this.objectIdLookupTable[2]);
                    this.a(7, 3, 0, 2, this.cc + this.var_byte_arr_U[4], this.objectIdLookupTable[2]);
                }
            }
            if (n2 >= 10 && n2 < 13) {
                this.a(null, 240, this.objectIdLookupTable[2], 3, 0, 4, this.cc + this.var_byte_arr_U[n2 - 9 << 1], this.objectIdLookupTable[2], n2 - 9, -1);
                return;
            }
            if (n2 >= 14 && n2 <= 17) {
                this.a(null, this.cc + this.var_byte_arr_U[n2 - 10 << 1], 320, 3, 0, 4, this.cc + this.var_byte_arr_U[n2 - 10 << 1], this.objectIdLookupTable[2], n2 - 10, -1);
                return;
            }
            if (n2 >= 25 && n2 <= 31) {
                n = (n2 - 25 << 1) + 8;
                this.a(null, this.cc + this.var_byte_arr_U[n << 1], this.objectIdLookupTable[2], 3, 0, 0, this.cc + this.var_byte_arr_U[n << 1], this.objectIdLookupTable[2], n, -1);
                if (n2 < 31) {
                    this.a(null, this.cc + this.var_byte_arr_U[++n << 1], this.objectIdLookupTable[2], 3, 0, 0, this.cc + this.var_byte_arr_U[n << 1], this.objectIdLookupTable[2], n, -1);
                }
                return;
            }
        } else {
            if (n2 >= 18 && n2 < 31) {
                this.a(null, this.cc + this.var_byte_arr_U[n2 - 10 << 1], 320, 3, 0, 4, this.cc + this.var_byte_arr_U[n2 - 10 << 1], this.objectIdLookupTable[2], n2 - 10, -1);
            }
            switch (n2) {
                case 50: {
                    this.a(2, 2, 4, 4, 4, 1);
                    break;
                }
                case 51: {
                    this.a(3, 2, 4, 4, 4, 1);
                    break;
                }
                case 52: {
                    this.a(4, 2, 4, 4, 4, 1);
                    break;
                }
                case 58: {
                    this.a(0, 1, 0, 1, 1000, 1000);
                    this.a(1, 2, 4, 4, 4, 1);
                    break;
                }
                case 63: {
                    this.a(15, 3, 0, 4, -10, this.objectIdLookupTable[2]);
                }
            }
            if (n2 > 52 && n2 < 63) {
                n = n2 - 52;
                this.a(n + 4, 3, 0, 4, -10, this.objectIdLookupTable[2]);
                this.a(26 - n, 3, 0, 4, 240, this.objectIdLookupTable[2]);
            }
        }
    }

    private void H() {
        this.var_javax_microedition_lcdui_Graphics_a.setColor(0xFFFFFF);
        this.var_javax_microedition_lcdui_Graphics_a.fillRect(0, 0, 240, 320);
        for (int i = 0; i < this.var_byte_D; ++i) {
            int[] nArray = this.var_int_arr_arr_d[i];
            int n = nArray[0];
            int n2 = nArray[1];
            if (nArray[2] == 3 || nArray[2] == 4) {
                this.var_javax_microedition_lcdui_Graphics_a.setClip((n -= this.var_byte_arr_U[nArray[6] << 1]) + this.var_byte_arr_U[nArray[6] << 1], n2, (int)this.var_byte_arr_U[(nArray[6] << 1) + 1], 320);
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.gamePngImagesGroups[0][7], n, n2, 0);
            } else if (nArray[2] == 2) {
                int n3 = nArray[3] - nArray[4];
                if (nArray[5] == 1) {
                    n3 = nArray[3] - n3 - 2;
                }
                this.var_javax_microedition_lcdui_Graphics_a.setClip((n -= nArray[6] * n3) + nArray[6] * n3, n2, nArray[6], 320);
            }
            if (nArray[2] != 3 && nArray[2] != 4) {
                this.var_javax_microedition_lcdui_Graphics_a.drawImage(this.var_javax_microedition_lcdui_Image_arr_b[i], n, n2, 0);
            }
            this.var_javax_microedition_lcdui_Graphics_a.setClip(0, 0, 240, 320);
        }
    }

    private void a(Image image, int n, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9) {
        if (this.var_javax_microedition_lcdui_Image_arr_b == null) {
            this.var_javax_microedition_lcdui_Image_arr_b = new Image[26];
        }
        if (this.var_byte_D < 26) {
            int[] nArray = this.var_int_arr_arr_d[this.var_byte_D];
            if (n9 >= 0 && n9 < this.var_byte_D) {
                this.var_int_arr_arr_d[this.var_byte_D] = this.var_int_arr_arr_d[n9];
                this.var_javax_microedition_lcdui_Image_arr_b[this.var_byte_D] = this.var_javax_microedition_lcdui_Image_arr_b[n9];
                this.var_javax_microedition_lcdui_Image_arr_b[n9] = image;
                this.var_int_arr_arr_d[n9] = nArray;
                nArray = this.var_int_arr_arr_d[n9];
            } else {
                this.var_javax_microedition_lcdui_Image_arr_b[this.var_byte_D] = image;
            }
            if (n3 == 3) {
                nArray[6] = n8;
            } else {
                n8 = image.getWidth();
                int n10 = image.getHeight();
                if (n3 == 2) {
                    nArray[6] = n8 /= n5;
                }
                n9 = 0;
                int n11 = 0;
                if ((n4 & 1) != 0) {
                    n9 = 0 - n8;
                } else if ((n4 & 4) != 0) {
                    n9 = 0 - (n8 >> 1);
                }
                if ((n4 & 2) != 0) {
                    n11 = 0 - (n10 - 1);
                } else if ((n4 & 8) != 0) {
                    n11 = 0 - ((n10 >> 1) - 1);
                }
                n += n9;
                n2 += n11;
                if (n3 == 1) {
                    n6 += n9;
                    n7 += n11;
                }
            }
            nArray[0] = n;
            nArray[1] = n2;
            nArray[2] = n3;
            nArray[3] = n5;
            nArray[4] = n6;
            nArray[5] = n7;
            this.var_byte_D = (byte)(this.var_byte_D + 1);
        }
    }

    private void a(int n, int n2, int n3, int n4, int n5, int n6) {
        if (n < this.var_byte_D) {
            int[] nArray = this.var_int_arr_arr_d[n];
            if (n2 == 1) {
                int n7 = this.var_javax_microedition_lcdui_Image_arr_b[n].getWidth();
                int n8 = this.var_javax_microedition_lcdui_Image_arr_b[n].getHeight();
                if ((n3 & 1) != 0) {
                    n5 -= n7;
                } else if ((n3 & 4) != 0) {
                    n5 -= n7 >> 1;
                }
                if ((n3 & 2) != 0) {
                    n6 -= n8 - 1;
                } else if ((n3 & 8) != 0) {
                    n6 -= (n8 >> 1) - 1;
                }
            }
            nArray[2] = n2;
            nArray[3] = n4;
            nArray[4] = n5;
            nArray[5] = n6;
        }
    }

    private void v(int n) {
        if (n >= 0) {
            if (n < this.var_byte_D) {
                int[] nArray = this.var_int_arr_arr_d[n];
                this.var_byte_D = (byte)(this.var_byte_D - 1);
                this.var_int_arr_arr_d[n] = this.var_int_arr_arr_d[this.var_byte_D];
                this.var_int_arr_arr_d[this.var_byte_D] = nArray;
                this.var_javax_microedition_lcdui_Image_arr_b[n] = null;
                this.var_javax_microedition_lcdui_Image_arr_b[n] = this.var_javax_microedition_lcdui_Image_arr_b[this.var_byte_D];
                this.var_javax_microedition_lcdui_Image_arr_b[this.var_byte_D] = null;
                return;
            }
        } else {
            this.var_byte_D = 0;
            this.var_javax_microedition_lcdui_Image_arr_b = null;
        }
    }

    private void I() {
        if (this.var_javax_microedition_io_HttpConnection_a != null) {
            try {
                this.var_javax_microedition_io_HttpConnection_a.close();
            }
            catch (Exception exception) {}
            this.var_javax_microedition_io_HttpConnection_a = null;
        }
        if (this.var_java_io_OutputStream_a != null) {
            try {
                this.var_java_io_OutputStream_a.close();
            }
            catch (Exception exception) {}
            this.var_java_io_OutputStream_a = null;
        }
        if (this.var_java_io_InputStream_b != null) {
            try {
                this.var_java_io_InputStream_b.close();
            }
            catch (Exception exception) {}
            this.var_java_io_InputStream_b = null;
        }
        System.gc();
    }

    private int int_c() {
        return (this.var_byte_arr_W[this.cg++] & 0xFF) << 8 | this.var_byte_arr_W[this.cg++] & 0xFF;
    }

    private int int_d() {
        return this.int_c() << 16 | this.int_c() & 0xFFFF;
    }

    private int int_e() {
        int n = 0;
        try {
            String string;
            Object object;
            String string2;
            String string3 = string2 = this.var_java_lang_String_g == null ? this.var_java_lang_String_arr_r[0] : this.var_java_lang_String_g;
            Object object2 = this;
            if (((a)object2).var_boolean_H) {
                int n2 = string3.indexOf(47, 7);
                object = string3.substring(n2);
                string = "http://10.0.0.172:80" + (String)object;
            } else {
                string = string3;
            }
            object = string;
            object2 = string2;
            int n3 = ((String)object2).indexOf(47, 7);
            string2 = n3 < 7 ? ((String)object2).substring(7, ((String)object2).length()) : ((String)object2).substring(7, n3);
            this.var_javax_microedition_io_HttpConnection_a = (HttpConnection)Connector.open((String)object);
            this.var_javax_microedition_io_HttpConnection_a.setRequestMethod("POST");
            this.var_javax_microedition_io_HttpConnection_a.setRequestProperty("Content-Type", "application/octet-stream");
            if (this.var_boolean_H) {
                this.var_javax_microedition_io_HttpConnection_a.setRequestProperty("X-Online-Host", string2);
            }
            this.var_javax_microedition_io_HttpConnection_a.setRequestProperty("Content-Length", "" + 0);
            if (this.var_byte_arr_V != null) {
                this.var_java_io_OutputStream_a = this.var_javax_microedition_io_HttpConnection_a.openOutputStream();
                this.var_java_io_OutputStream_a.write(this.var_byte_arr_V, 0, 0);
                this.var_java_io_OutputStream_a.flush();
            }
            this.ce = this.var_javax_microedition_io_HttpConnection_a.getResponseCode();
            if (this.ce >= 300 && this.ce < 400) {
                this.var_java_lang_String_h = "重定向!!!";
                this.var_java_lang_String_g = this.var_javax_microedition_io_HttpConnection_a.getHeaderField("Location");
                n = 1;
            } else if (this.ce / 100 != 2) {
                n = -1;
            } else {
                n = 0;
                while (true) {
                    object = null;
                    object2 = this.var_javax_microedition_io_HttpConnection_a.getHeaderFieldKey(n);
                    if (object2 == null) break;
                    this.var_javax_microedition_io_HttpConnection_a.getHeaderField(n);
                    ++n;
                }
                this.var_java_io_InputStream_b = this.var_javax_microedition_io_HttpConnection_a.openInputStream();
                n = (int)this.var_javax_microedition_io_HttpConnection_a.getLength();
                if (n > 0) {
                    this.var_byte_arr_W = null;
                    this.var_byte_arr_W = new byte[n];
                    int n4 = 0;
                    for (int i = 0; i < n; ++i) {
                        n4 = this.var_java_io_InputStream_b.read();
                        this.var_byte_arr_W[i] = (byte)n4;
                    }
                } else {
                    object = new ByteArrayOutputStream(2048);
                    boolean bl = false;
                    byte[] byArray = new byte[64];
                    while ((n = this.var_java_io_InputStream_b.read(byArray, 0, 64)) >= 0) {
                        ((ByteArrayOutputStream)object).write(byArray, 0, n);
                    }
                    ((ByteArrayOutputStream)object).close();
                    this.var_byte_arr_W = ((ByteArrayOutputStream)object).toByteArray();
                }
                this.var_java_io_InputStream_b.close();
                this.var_java_io_InputStream_b = null;
                n = this.var_byte_arr_W.length;
                Object object3 = new byte[n >> 1];
                int n5 = 0;
                while (n5 + 1 < n) {
                    object3[n5 >> 1] = a.int_h(this.var_byte_arr_W[n5]) << 4 | a.int_h(this.var_byte_arr_W[n5 + 1]);
                    n5 += 2;
                }
                this.var_byte_arr_W = null;
                this.var_byte_arr_W = object3;
                object3 = new StringBuffer();
                for (n5 = 0; n5 < (n >>= 1); ++n5) {
                    ((StringBuffer)object3).append(Integer.toHexString(this.var_byte_arr_W[n5] & 0xFF));
                    ((StringBuffer)object3).append(" ");
                }
                System.out.println("下行数据长度：" + n + "，内容：" + object3);
                n = 0;
            }
        }
        catch (Exception exception) {
            n = -1;
        }
        finally {
            this.I();
        }
        return n;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private int int_f() {
        int n;
        Object object = this.var_java_lang_Object_a;
        synchronized (object) {
            n = this.cf;
        }
        if (n == 2) {
            Thread.yield();
        }
        return n;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private boolean boolean_b() {
        ++this.cj;
        switch (this.int_f()) {
            case 0: {
                this.cj = 0;
                this.ck = 0;
                this.cj = 0;
                try {
                    if (this.ce == 200) {
                        a a2 = this;
                        long l = 0L;
                        a2.cg = 0;
                        a a3 = a2;
                        l = a3.int_d() << 32 | a3.int_d();
                        if (l > 0L) {
                            a2.ci = 0;
                            a2.var_long_b = a2.var_long_a;
                            a2.var_long_a = l;
                            a2.ch = a2.var_byte_arr_W[a2.cg++];
                            for (int i = 0; i < a2.ch; ++i) {
                                a3 = a2;
                                ++a3.cg;
                                int n = a3.int_c();
                                if (n == 0) continue;
                                a3.cg += n;
                            }
                        } else {
                            if (++a2.ci >= 2 && a2.var_long_b != a2.var_long_a) {
                                a2.var_long_a = a2.var_long_b;
                            }
                            Object object = a2.var_java_lang_Object_a;
                            synchronized (object) {
                                a2.cf = -1;
                            }
                            a2.var_java_lang_String_h = a2.var_java_lang_String_arr_q[48];
                        }
                    }
                }
                catch (Exception exception) {
                    Exception exception2 = exception;
                    exception.printStackTrace();
                }
                finally {
                    this.I();
                }
                return true;
            }
            case -1: {
                if (this.ck < 3) {
                    ++this.ck;
                    this.cj = 0;
                    this.var_java_lang_String_h = "正在重试(" + this.ck + ")";
                    a a4 = this;
                    a4.I();
                    a4.ce = 0;
                    a4.cj = 0;
                    if (a4.var_java_lang_Object_a == null) {
                        a4.var_java_lang_Object_a = new Object();
                    }
                    Object object = a4.var_java_lang_Object_a;
                    synchronized (object) {
                        a4.cf = 2;
                    }
                    a4.var_boolean_F = true;
                    Thread thread = new Thread(a4);
                    thread.start();
                    break;
                }
                this.ck = 0;
                this.var_java_lang_String_h = this.var_java_lang_String_arr_q[15];
                this.var_boolean_H = !this.var_boolean_H;
                return true;
            }
        }
        if (this.cj > 300) {
            this.cf = 3;
            this.cj = 0;
            this.var_java_lang_String_h = "已超时，请重试。";
            this.var_boolean_H = !this.var_boolean_H;
            return true;
        }
        return false;
    }

    private static int int_h(int n) {
        if (n >= 48 && n <= 57) {
            return n - 48;
        }
        if (n >= 97 && n <= 122) {
            return n - 97 + 10;
        }
        if (n >= 65 && n <= 90) {
            return n - 65 + 10;
        }
        return -n;
    }

    static {
        var_int_arr_b = new int[]{0, 8192, 16384, 24576, 8462, 270, 90, 8282};
        int[] nArray = new int[]{0, 2, 1, 3, 4, 5, 6, 7};
    }
}

